Rating: 
Summary: Up to speed quickly with Eclipse
Review: A solid introduction to Eclipse (emphasis on introduction). Eclipse has been around for over a year, and yet there were no books about it until May of this year. Now, in rapid succession, this book, the Shavor book, and the Pluta book have appeared. (Not having seen the Pluta book, I can't comment on it).If you're just an average Java programmer (excuse me, developer; we're all developers now!), then this one seems to be the one to buy. The writing is clear and to the point, it includes an introduction to JUnit, CVS, and Ant and how they integrate into Eclipse, and it even has a brief (probably too brief) appendix on SWT. Two chapters are devoted to writing plug-ins; this is plenty to get started. The examples are short but useful, and all the source code for them is available on the Manning web site (no CD included in the book). (Sidebar: The authors exhibit a refreshing honesty. Instead of the obligatory bow-and-scrape tribute to pair programming, they write "More developers are probably talking about [it] than doing it". Bravo!) Bottom line: If you are a guru who is going to be writing lots of plug-ins, and/or you need to know more about SWT, then you probably want to read the Shavor book also. But if you are new to Eclipse, and just want to get up to speed quickly on using Eclipse as a Java IDE, this book is a great place to start.
Rating: 
Summary: An Excellent Guide
Review: 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.
Rating:
Summary: Excellent book on Eclipse
Review: I have been a user of Eclipse for over a year and I found that Eclipse In Action does a great job of describing many of the facets of Eclipse that I found the most interesting, and in some cases the most complex, in a easy to understand format. Rather than covering every last aspect of Eclipse this book does an excellent job covering an important subset of Eclipse's functionality. This book is, of course, not for novice Java developers. It is not a book on learning Java using Eclipse, but how to use Eclipse efficiently to develop Java programs. The bulk of the book covers the Java Development Tooling plug-in in a variety of scenarios using JUnit, Ant, CVS, log4j and a couple of open source plug-ins. The remaining 2 chapters are a nice introduction to extending Eclipse using its plug-in architecture. This book is clear in its explanations to a fault. Well done, David, Ed and Robert!
Rating:
Summary: Eclipse In Action - UPHPU
Review: I reviewed Eclipse In Action to familiarize myself with the IDE Eclipse. My main focus while reading the book was to learn all I can about developing with Eclipse. I wanted to be able to utilize all the features that Eclipse has to offer, not only in terms of Java developer, but also as a web developer. However, I want to point out that this book is "A Guide for Java Developers". So the target audience is for a Java Developer.
The book starts out with a great introduction into Eclipse and the how the IDE comes together in the workbench. The moves right into the Java development with Eclipse. It wastes no time getting to the meat of development with Junit, Log4j, testing, debugging, and Ant integration. Not to mention a chapter on CVS integration. The book everything that a developer needs during the development life cycle of their project. The authors do a great job in adding additional information on the features that Eclipse has to offer to help alleviate the remedial tasks during development. Many of these features can be used outside of Java development.
Part 2 of Eclipse In Action deals with extending Eclipse and creating Eclipse plugins (the foundation of Eclipse). These chapters give a great novice introduction into Eclipse plugin development; however, there seems to be lacking detail into SWT/JFace and advanced plugin development.
Overall Eclipse In Action provides an indepth look into the Eclipse IDE. I would recommend this book to anyone that want to use Eclipse as their IDE. I have been using Eclipse for over a year now and I use it for all languages I develop with, like Java and PHP. Though the book focuses on the Java Developer, this also lends it way into development with other languages.
Rating:
Summary: Good for learning Eclipse
Review: I was already using Eclipse when I purchased this book. However, I did not know the tricks, shortcuts and I could not take adventage of the features of Eclipse fully until I started reading "Eclipse in Action". The examples in the book are easy to follow and help you quickly understand the ideas. I would prefer to see more screenshots though. Probably the authors did not want to increase the volume of the book. All in all, it is a great book!...
Rating:
Summary: Code like you've got three hands!
Review: If you've wondered if switching to Eclipse can improve your productivity, check out the guy on the cover with three hands! I've been using Eclipse for over a year now and can't believe how much I was missing. Sure, I knew about Ant integration, but the book explains why some of my scripts run fine in command line and not from Eclipse. JUnit, CVS, log4j and Tomcat integration are all detailed as well. Eclipse in Action shows you how to create your own simple plug-ins, manage your coding activities and get the most out of this way cool IDE.
Rating:
Summary: Great Book in Less Than 400 Pages
Review: 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.
Rating:
Summary: Much needed book
Review: This book certainly fills in a need for a well organized, easy to read and exhaustive reference for the open source Eclipse IDE and platform. The book is in fact quite ambitious since it seems to want to teach readers how to program, how to design and build software, how to use the Eclipse IDE as well as how to use a number of open source tools such as ANT, Log4J, JUnit, CVS, Tomcat, SWT and JFace and even XML! The surprise is that it pretty much achieves its goal. Seasoned Java programmers may elect to skim through the more familiar sections and concepts and concentrate on the Eclipse specific stuff. I tried to find one important Eclipse feature that was not at least mentioned but could not find one. Even developers very much familiar with Eclipse will probably learn new tricks by going through the various chapters. I was expecting more or less a user's guide to the Eclipse IDE but in addition I found a very good although brief introduction to the Eclipse APIs and platform as well as relevent material on how to extend Eclipse by writing plug-ins A few other books on Eclipse were recently published but I cannot compare not having read them but this one is certainly useful for newbies as well as regular Eclipse users and developers.
Rating:
Summary: An Eclipse Textbook
Review: 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.
Rating:
Summary: Practical introduction to Eclipse
Review: This is a solid introduction to Eclipse from the user level. It guides you through installing Eclipse, starting your first project, and integrating with source control. There is a small section on writing a plugin, but it's not the emphasis of the book.
O'Reilly's Eclipse books spent about half their time on Eclipse and the other half on plain Java development which was a waste of space. This book spends on chapter on web development, and some of that chapter is spent on use of Eclipse in that context. It's a diversion in both the Manning and O'Reilly books, but the O'Reilly books are far worse.
This is the best introduction to end-user Eclipse that I have read. If you want a book on getting started with Eclipse as a Java development IDE, this is the one.
| 
