Eclipse in Action: A Guide for the Java Developer (Paperback)

by David Gallardo (Author), Ed Burnette (Author), Robert McGovern (Author)

Editorial Reviews

Review
"The technical information is dead on...I'd definitely recommend this book to anyone." -- JavaRanch.com

Product Description
Eclipse is a new open-source, Java-based, extensible development platform designed for nothing in particular but everything in general. Because of its roots, it is currently most popular as a Java integrated development environment (IDE). Eclipse ships with plugins for writing and debugging Java code. Additional plugins for more advanced Java development, such as JSP/servlets, are available from third parties.

This book provides a thorough guide to using Eclipse features and plugins effectively in the context of real-world Java development. Realistic examples demonstrate how to use Eclipse effectively to build, test and debug applications using the tools provided by Eclipse and other third-party open source plugins. The reader will learn how to use plugin tools for using Eclipse in a team environment, including using Ant for more sophisticated build processes and CVS for source control. Plugin-ins for building web applications, using J2EE technologies, such as JSP/Servlets and EJB, are also discussed.

Complementing this coverage of Eclipse in the context of development is a reference providing a comprehensive guide to Eclipse. Because Eclipse and its plugins provide a remarkable array of features, it is often hard to learn what features are available and how they can be invoked. This reference lays things out clearly: feature-by-feature, menu-by-menu.

What's inside:
* Getting started with the Eclipse Workbench: Perspectives, views and editors
* Working effectively with the Eclipse JDT
* Adding unit tests with JUnit, logging with log4j
* Team development with Ant and CVS
* Plugins for J2EE including the Sysdeo Tomcat plugin
* Developing Eclipse plugins
* Comprehensive Eclipse reference

See all Editorial Reviews

Product Details

• Paperback: 380 pages
• Publisher: Manning Publications; 7th edition (May 15, 2003)
• Language: English
• ISBN-10: 1930110960
• ISBN-13: 978-1930110960
• Product Dimensions: 9.1 x 7.3 x 0.9 inches
• Shipping Weight: 1.5 pounds (View shipping rates and policies)
• Average Customer Review: 4.5 out of 5 stars See all reviews (13 customer reviews)
• Amazon.com Sales Rank: #464,806 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

21 of 21 people found the following review helpful:

4.0 out of 5 stars An Eclipse Textbook, February 6, 2004

By	Donald A Benish (Offerle, KS United States) - See all my reviews

This book is a very good explanation of what Eclipse is and does. It does assume the reader is somewhat familiar with IDEs and quite familiar with Java. It describes the reasons for Eclipse coming about and the way it is different from other IDEs. It gives some description of how to use it to start a project and how to set some preferences and properties. It does not give all the various details about every preference and property but does give some idea about how to find out what they are and do.
The examples it uses are on some very basic and useful features that Eclipse has integrated well. There is an overview on the Junit plugin and how to use it to do unit testing. Eclipse was designed with the focus on Agile or 'Extreme' programming style. The examples are decribed in the language of that paradigm. The unusual part of the book's style is how it presents an example of a problem and a solution, and then it may state that this isn't the best way to solve this problem and presents an alternative approach that is more practical, and so on. In this style, the book is more of a textbook and less of a reference. You need to read the whole book and proceed with examples as if it were a series of classroom lectures rather than as a way to quickly find out how to do something. Many of the example programs that can be downloaded from the website don't actually work but serve to demonstrate some feature of Eclipse.
One frustration, which I find in many such books, is that the example problems are uninteresting and trite. Many such books offer some baloney programs such as a car/vehicle/machine issue, which can be rather boring and pointless. This book offers a similarly boring problem of a star finder. I would love to see a book whose example yields an application that I might actually care to use.
The book also describes how to use the Ant plugin, which is useful for someone building a large application with many setting options. Eclipse provides a way to tie all the various Ant features into a neat package. Since I had never used Ant or Junit these discussions were very useful but for someone with experience with them may be less enlightening.
The book also covers briefly how to use Eclipse's source control features and how to use a Tomcat server within Eclipse. These are features that probably everyone needs to use and the book discusses how to set them up to work with and be controlled from within Eclipse. These do require some reader ability and familiarity with the tools. You may need to do some outside reading if you do not have a CVS server or have not installed Tomcat before.
The last third of the book involves using Eclipse to create your own plugin. The example uses a common application introduced earlier in the book, log4j, which is an open source logger tool. The early reference merely used log4j to implement logging in an example. The plugin development section instructs you to build a set of plugins to wrap log4j as an Eclipse plugin so that the control of the logger is done entirely within Eclipse. This section also describes how Eclipse uses plugins to extend other plugins and how the usefulness of the tool grows as new plugins get introduced. It is a rather complicated bit and may not be of great interest to every programmer but does give an idea of how the development of Eclipse is proceeding.
The appendixes give some reference material to menus and plugin extension points, i.e. classes that tie plugins together. There are also brief appendixes on installing a CVS server, and using SWT and JFace. In my view they should be considered only introductions and would need outside reading to become useful.

21 of 21 people found the following review helpful:

4.0 out of 5 stars An Excellent Guide, June 25, 2003

By	C. McGlone - See all my reviews (REAL NAME)

For anyone that doesn't know about it, Eclipse is an IDE that is freely available and is usable for really just about anything. It's designed for versatility and it succeeds brilliantly. Of course, with increased versatility usually comes increased complexity. Eclipse In Action is written with Java developers in mind and leads you through the major functionality and extensibility of the IDE through in depth examples. The examples are great and have a nice depth (they don't feel as contrived as most examples in books like this). This has some definite benefits - you feel like you're getting real-life experience by doing examples and it makes the book smoother to read front to back. However, there is a drawback - this book doesn't always make a handy reference to put on the shelf. To figure out how something works, sometimes I find myself looking back a chapter or two to see how the example works so that I can work forward. I found that this book lent itself to being read straight through rather than picking out chapters to read individually. I found the book easy and enjoyable to read, although you'll probably want to be sitting in front of your computer working along to get the most out of it. The technical information is dead on and I found few mistakes - the editing is done very well. I'd definitely recommend this book to anyone that wants to get the most out of Eclipse.

19 of 19 people found the following review helpful:

5.0 out of 5 stars Great Book in Less Than 400 Pages, September 28, 2003

By A Customer

Now that you've downloaded Eclipse and realized it is a big tool, if you are like me you thought you'd go looking for some books on the subject. I'd suggest stopping right here.

One pundant on usenet suggested that Eclipse has a learning curve like Emacs and that this is a good thing, because of boths power and flexibility. While I think Eclipse is more usable and seems to be easier to extend than that old war horse EMACS, the scope of what IS in Eclipse can be daunting. More importantly it is useful to get your head around the way the GUI is organized, so you can effecticvely use the tool. At less than 400 pages, you might think this book would not cover the ground, but this is not the case. This book specifically says it is not intended as a hardcopy version of the on-line help. The goal of the book is to get you started and you move you into some of the more interesting aspects of the IDE. I found the book to have succeeded well at it goal.

Continuing a recent trend from Manning this seems to be another well edited book that is kept managable in size, yet still containing a large amount of information. The book doesn't waste a lot of time getting started, by chapter three you are already learning about using JUnit, Log4J and the debugger. In later chapters, the authors have you working with Ant and CVS after working up a nice little example that that they even spend some time refactoring using the built in features of Eclipse. Integrated tool use would probably be sufficient, but they proceed to jump off into web development leveraging one of the hundreds of plugins available for Eclipse and show you how to debug directly in Eclipse using tomcat. In just over 200 pages a lot of very useful material has been covered.

Part 2 of the book goes on to show you how to write your own plugins which I haven't done yet, so can't comment. For those who just can't stand a well written narrative and instructional style, there is even a thin 16 page chapter of mostly tables for all the Java development menu options and another appendix listing all plug-in extension points. For those who are wondering if they can replace the IDEs they have which help with their Swing layout and development, you may be interested in noting that the SWT is regulated to its own appendix keeping with the emphasis of Java on the server. Since Eclipse is an open API and open source there are 300+ of plugins available for it. There are at least two Swing development plugins available, most of which appear to be in their early stages of development

So if you thought that such a little book wouldn't cover much more than what real newbie would need you will missing a good book.