Recommended books about Eclipse

For too long, developers have worked on disorganized application projects, where every part seemed to have its own build system, and no common repository existed for information about the state of the project. Now there's help. The long-awaited official documentation to Maven is here.

Written by Maven creator Jason Van Zyl and his team at Sonatype, Maven: The Definitive Guide clearly explains how this tool can bring order to your software development projects. Maven is largely replacing Ant as the build tool of choice for large open source Java projects because, unlike Ant, Maven is also a project management tool that can run reports, generate a project website, and facilitate communication among members of a working team.

To use Maven, everything you need to know is in this guide. The first part demonstrates the tool's capabilities through the development, from ideation to deployment, of several sample applications -- a simple software development project, a simple web application, a multi-module project, and a multi-module enterprise project.

The second part offers a complete reference guide that includes:

• The POM and Project Relationships
• The Build Lifecycle
• Plugins
• Project website generation
• Advanced site generation
• Reporting
• Properties
• Build Profiles
• The Maven Repository
• Team Collaboration
• Writing Plugins
• IDEs such as Eclipse, IntelliJ, ands NetBeans
• Using and creating assemblies
• Developing with Maven Archetypes

Several sources for Maven have appeared online for some time, but nothing served as an introduction and comprehensive reference guide to this tool -- until now. Maven: The Definitive Guide is the ideal book to help you manage development projects for software, web applications, and enterprise applications. And it comes straight from the source.

The best way to show off a powerful new technology is to demonstrate real-world results with it, and that's exactly what Adobe and O'Reilly have done with Flex 3. Through it's Flex Cookbook website, Adobe invited users of the Flex 3 beta to post their own solutions for working with this technology, using O'Reilly's popular problem-solution-discussion format. Website monitors (and authors) Joshua Noble and Todd Anderson chose the most useful solutions for Flex 3 Cookbook. This highly practical book contains more than 200 proven recipes for developing interactive Rich Internet Applications and Web 2.0 sites, including several contributed by Noble, Anderson, and other Flex experts. You'll find everything from Flex basics and working with menus and controls, to methods for compiling, deploying, and configuring Flex applications. Each recipe features a discussion of how and why it works, and many of them offer sample code that you can put to use immediately. Topics include: Menus and controls Containers and dialogues Working with Text List, tiles, trees, and repeaters DataGrid and Advanced DataGrid Renderers Images, videos, and sounds CSS and skinning Building components States and effects Collections, arrays, and DataProviders DataBinding Validation/formatters Charting and data visualization State management, SharedObjects and LocalConnection Working with services and ServerSide communication Working with XML Communicating with the browser Application development strategies Runtime and dynamic shared libraries and modules Working with Adobe AIR Whether you're a committed Flex developer, or still evaluating the technology, you'll discover how to get quick results with Flex 3 using thesethese recipes. Now that Flex is an open source framework, the user community will continue to supply solutions to extend and improve the technology. This Cookbook offers you the cream of the crop.

I haven't read all of this book, but from what I've seen, it is pretty good info. The format is good, listing a problem, a solution, and a discussion. I've read some good and not so great Flex books and I have noticed books with Todd Anderson as the author have been good(see Adobe Air, create modify reuse).

-I did not read Flex 2 Cookbook - the information looks new to me!
-There will be some errors in any book, especially programming books. With the Flex technology changing so fast, I would rather see a book rushed to market than months spent trying to cleanup every typo and minor compile errors(as other reviewers have said). We can figure out what typos and minor compile errors are supposed to be.

I have approx 6 flex books and this one is at the top of my list right now.

In my progression as a budding Flex developer I have reached the point where I'm passed the "getting started" tutorials but still not a master of anything with the language. My questions have from general concepts to the much more specific. This book is perfectly tailored to provide the answers I needed.

The format of the publication is set up nicely as it states a problem and then explains a solution. The way I usually judge a book's worth is to attack it with a specific question in mind, and then see how well it helps me solve the problem. The Flex 3 Cookbook passed with flying colors.

I needed some help wrapping my mind around manipulating data in an ArrayCollection. Section 13.1 called 'Add, Sort, and Retrieve Data from an ArrayCollection' guided me to a much better understanding of ArrayCollections. My question was answered, although there was a typo in the example code, hence the 4-star rating rather than 5.

I was hoping for more than just the trivial examples that you can get anywhere. There are a few, but not nearly enough. No charting examples at all. Its clear that this compilation of ideas was created ad hoc and not well thought out. Even so, it has saved me some time here and there.

The Flex 3 Cookbook is an amazing resource, and it should be found in the library of any Flex developer. Its solution based training provides motivation for completing projects while filling in potential gaps of knowledge. Not the definitive book, but an excellent resource.

I just got this book and am using it already in my projects. Great source of real life solutions, very enjoyable to read. Highly recommended!

Debugging is crucial to successful software development, but even many experienced programmers find it challenging. Sophisticated debugging tools are available, yet it may be difficult to determine which features are useful in which situations. The Art of Debugging is your guide to making the debugging process more efficient and effective.

The Art of Debugging illustrates the use three of the most popular debugging tools on Linux/Unix platforms: GDB, DDD, and Eclipse. The text-command based GDB (the GNU Project Debugger) is included with most distributions. DDD is a popular GUI front end for GDB, while Eclipse provides a complete integrated development environment.

In addition to offering specific advice for debugging with each tool, authors Norm Matloff and Pete Salzman cover general strategies for improving the process of finding and fixing coding errors, including how to:

• Inspect variables and data structures
• Understand segmentation faults and core dumps
• Know why your program crashes or throws exceptions
• Use features like catchpoints, convenience variables, and artificial arrays
• Avoid common debugging pitfalls

Real world examples of coding errors help to clarify the authors' guiding principles, and coverage of complex topics like thread, client-server, GUI, and parallel programming debugging will make you even more proficient. You'll also learn how to prevent errors in the first place with text editors, compilers, error reporting, and static code checkers.

Whether you dread the thought of debugging your programs or simply want to improve your current debugging efforts, you'll find a valuable ally in The Art of Debugging.

There are dozens of Java frameworks out there, but most of them require you to learn special coding techniques and new, often rigid, patterns of development. Wicket is different. As a component-based Web application framework, Wicket lets you build maintainable enterprise-grade web applications using the power of plain old Java objects (POJOs), HTML, Ajax, Spring, Hibernate and Maven. Wicket automatically manages state at the component level, which means no more awkward HTTPSession objects. Its elegant programming model enables you to write rich web applications quickly.

Wicket in Action is an authoritative, comprehensive guide for Java developers building Wicket-based Web applications. This book starts with an introduction to Wicket's structure and components, and moves quickly into examples of Wicket at work. Written by two of the project's earliest and most authoritative experts, this book shows you both the "how-to" and the "why" of Wicket. As you move through the book, you'll learn to use and customize Wicket components, how to interact with other technologies like Spring and Hibernate, and how to build rich, Ajax-driven features into your applications.

There is already a lot of appreciation of the book, don't have much to say here

I have been developing with Wicket for a year or so. When I started working with Wicket I didn't have a good book as a reference. The community is very helpful in this case. In the mailing list you can sometimes see the two writers of this book. Their responses are very helpful. And so is the book.
The book covers a lot of theoretical Wicket stuff, which I think is very useful if one wants to understand it better.
The book is great for a newcomer as well. Just follow the examples and you'll understand Wicket.
I found the book very useful to me, an intermediate / expert Wicket developer.
Each time I read a few pages or a chapter, I learn something new.
I recommend this book to anyone that uses Wicket or plan to use it.

As the Manning publications book Wicket in Action is soon to hit the shelf of your local book store, I was granted the opportunity of a sneak preview. Now, I'm not a person with a lot of spare time on my hands these days but I felt an obligation to give this book a serious read because A) Wicket is an excellent framework for building web applications B) The people who wrote this book are extremely helpful on the mailing list and irc channel and I wanted to know if their talents translated well to book writing. I'm happy to report it has, in spades....
[...]

I already bought this book before it was released. I love wicket and this book sure makes it easier to work with Wicket. It gives you a great in depth view on how wicket works. Adding more and more complexity in all the different chapters.

A needed read for anyone who wants to get the most out of Wicket.

I don't normally review books on Amazon but this is one of the best technical books that I've read in a while. The authors do a great job of organizing and presenting the material. The book is easy to read and I was able to get through it in about two evenings. I'm now using it as a reference while I work on my first major Wicket application. It might help that Wicket itself is well structured which makes the concepts that much easier to understand.

That being said, there are a few short-comings:
1) The cheese and lasagna examples get really old really quickly. The authors could have used different concepts or something a little more relevant or interesting to most developers.

2) The book is somewhat short. While they covered the core topics well, I felt that a few things we missing. I was surprised to see that the publisher trimmed the book and put an extra chapter online but not in print.

3) Some fundamentals like what DTD to include in an HTML page or what the Wicket web.xml should look like would be nice. You can find these answers online with a quick search but this book should really cover it.

But these faults don't hurt the overall usefulness of the book. It would be nice if most/all of this documentation was available in the Wicket project itself, but no such luck which makes this book even more valuable. I don't know if it will be in all copies, but my copy had a coupon for a free version of the digital book (PDF I suppose)... nice touch.

I recommend buying this book and learning about a very reasonable alternative to JSF.

Eclipse is the world's most popular IDE for Java development. And although there are plenty of large tomes that cover all the nooks and crannies of Eclipse, what you really need is a quick, handy guide to the features that are used over and over again in Java programming. You need answers to basic questions such as: Where was that menu? What does that command do again? And how can I set my classpath on a per-project basis?

This practical pocket guide gets you up to speed quickly with Eclipse. It covers basic concepts, including Views and editors, as well as features that are not commonly understood, such as Perspectives and Launch Configurations. You'll learn how to write and debug your Java code--and how to integrate that code with tools such as Ant and JUnit. You'll also get a toolbox full of tips and tricks to handle common--and sometimes unexpected--tasks that you'll run across in your Java development cycle.

Additionally, the "Eclipse IDE Pocket Guide" has a thorough appendix detailing all of Eclipse's important views, menus, and commands.

The "Eclipse IDE Pocket Guide" is just the resource you need for using Eclipse, whether it's on a daily, weekly, or monthly basis. Put it in your back pocket, or just throw it in your backpack. With this guide in hand, you're ready to tackle the Eclipse programming environment.

Eclipse has tons of options and this guide will get you typing source code within 5 minutes.

I thought this would be a handy little "tips and tricks" reference. It basically just tells you all the obvious stuff you already figured out on your own. Save your money and just use the doc from the internet.

I've come to expect a lot from O'Reilly guides, and this one didn't let me down. It really helped me past some areas of confusion I had with Eclipse, although I think I may want a larger book eventually that gets into more detail on some of the add-ins.

The most common comment from the people I showed this book to was "I wish I had it when I started using Eclipse".

While this is a very small book, the contents have been selected to give you a best start with the main features of the Eclipse IDE. The topics are short but concise and include scattered tips for the points of interest.

If you're just starting with this IDE, the Eclipse IDE Pocket Guide will give you a great head start and will continue helping you as a lovely reference to refer back to as the features become familiar. Having all of these critical features pointed out earlier will save you a lot of bother in the future, since you'll be annoyed if you only find out about them much later by accident or experimentation!

Experienced users are less likely to get much from it though. The authors made a decision between content and size, and I feel they chose to stick with a smaller, simpler book than I would have expected. There is a final section on places to go for more information, but it just refers to various community sites.

I wish I had this book when I started using Eclipse.

I expected a little more from this book than creating a simple java file and compiling it. This book is for someone who is new to IDEs. This is *NOT* for someone trying for a quick reference to migrate from another IDE to Eclipse - which was my purpose.

Eclipse, a platform for building applications, was originally aimed at Web application and image manipulation. With the release of Eclipse 3.0 there has been a shift to the use of Eclipse as a Rich Client Platform (RCP). In other words, using Eclipse as a base for everyday generic applications from media players to productivity and desktop applications. Thinking of Eclipse as not just an IDE but a platform for all application building is an evolution for the platform and significantly extends its reach to developers. In this book the designers of Eclipse as an RCP introduces the reader to the RCP concept and walks them through a set of scenarios and examples using Eclipse to solve real world, application problems. This will appeal to all developers who want to develop and deploy world-class applications with rich, native GUIs. Development areas that are already using Eclipse RCP include bio-medical, embedded technology (handhelds, etc), enterprise and productivity applications and banking.

If you have a current installation of Eclipse and you are using JPA (ex: Hibernate), don't even think about using the book's update site. It will totally hose up your entire Eclipse installation and you are looking at a complete re-installation.

It's a shame, because otherwise the book seems to be very helpful. Rumor is that they are planning an update sometime late 2008, but none of the bookstores have a publication date on it yet.

I purchased 8 copies and distributed them to our team. Several team members went through each chapter, building the sample application on top of the Eclipse RCP. Each of us, whether or not we built the application, have learned a great deal about using Eclipse. I highly recommend this book to any software team that is starting a new product or that is in the throes of refactoring / recasting an old one. The book will jump-start your Eclipse experience.

I couldn't do my RCP application without this book. its example application goes growing showing everything we need to learn to make an RCP application.

I stumbled into Eclipse when researching OSGI as a framework for a system I was designing. I was not looking forward to the drudgery and complexity of building all the required infrastructure over OSGI to build an actual product - what a wonderful discovery to see this gleaming system with smoothly integrated parts ready to do my bidding!
The authors make the apt analogy of launching a payload into space - so much of the work goes into the launch vehicle and ground control,etc, whereas to the payload designer the only interesting work is at the very tip of the rocket. As software developers we love generating the cool idea (the payload) and are not so excited about the other 90% which makes the real product - complex UI workflows, help, update, packaging, etc. Eclipse provides all the mechanisms and plenty of automated assistance for putting together your total system.
Perhaps you will find some disparities between the book and your downloaded version of Eclipse (I haven't yet) but this is not Visual Basic, this is a relatively deep but elegantly designed system which does require a certain level of understanding before you really get cooking with it, but this book does an excellent job with that. Once you get going, it's like having a team of 10 great programmers at your command.

This book is a very detailed and at the same time hands on treatement of what the RCP paradigm is all about. It begins with how to create using Eclipse a very functional and easy to do Chat application. As it is this
application shows the most generic and neccessary aspects of how to start an RCP application all the way to branding and packaging within it's first serveral chapters. Its' full of suggestions and tips of why you're doing various things to what not to do and why.

This book is for anyone from someone just wanting to know how it's done up to a professional Eclipse developer level. The chapters are nice and short which helps when you want to read it between work and home.

It does read as though there was thorough thought and planning from a number of sources in the layout and planning of this book.

it also will satisfy anyone wanting to know the deeper meanings of why they had to do what they did in the first several chapters further on into this material.

To me the total material ranges from easy-do-it-yourself application build kit material to A-1 college material that could be used in a semester course of RCP and eclipse.

It also offers at the end several references to things like the OSGI model that eclipse is modeled on now as well as other interesting items you never knew but form the basis of this wonderful platform called eclipse.

Once you read this book and look at the references of what people have done with Eclipse (specifcally RCP) from Nasa to the banking industry,
you'll realize that Eclipse RCP is to Windows, Solaris, HP-UX, AIX, Linux and MacOSX as VisualStudio is to .NET

"Fully updated and revised for Eclipse 3.0, this book is the definitive Eclipse reference--an indispensable guide for tool builders, rich client application developers, and anyone customizing or extending the Eclipse environment." --Dave Thomson, Eclipse Project Program Director, IBM The Ultimate Guide to Eclipse 3.0 for the Java Developer. No Eclipse Experience Required! Eclipse is a world-class Java integrated development environment (IDE) and an open source project and community. Written by members of the IBM Eclipse Jumpstart team, The Java Developer's Guide to Eclipse, Second Edition, is the definitive Eclipse companion. As in the best-selling first edition, the authors draw on their considerable experience teaching Eclipse and mentoring developers to provide guidance on how to customize Eclipse for increased productivity and efficiency. In this greatly expanded edition, readers will find *A total update, including the first edition's hallmark, proven exercises--all revised to reflect Eclipse 3.0 changes to the APIs, plug-ins, UI, widgets, and more *A special focus on rich client support with a new chapter and two exercises *A comprehensive exercise on using Eclipse to develop a Web commerce application using Apache's Tomcat *A new chapter on JFace viewers and added coverage of views *A new chapter on internationalization and accessibility *New chapters on performance tuning and Swing interoperability Using this book, those new to Eclipse will become proficient with it, while advanced developers will learn how to extend Eclipse and build their own Eclipse-based tools. The accompanying CD-ROM contains Eclipse 3.0, as well as exercise solutions and many code examples. Whether you want to use Eclipse and Eclipse-based offerings as your integrated development environment or customize Eclipse further, this must-have book will quickly bring you up to speed.

The reason this book gets both great and lousy reviews is that Eclipse is such a huge subject. The writing of Eclipse plug-ins is simply a larger subject than any reasonable book can cover. If the topics that the authors chose to cover happen to align with the ones you personally need, then the book is excellent, but if they don't align, the book isn't going to help you much. Part I (six chapters) covers using Eclipse to write programs. Part II (seven chapters) covers the fundamentals of Extending Eclipse with plug-ins. Part III (9 chapters) covers plug-ins in more depth. Part IV (5 chapters) covers extending Eclipse with new tools for the IDE. Part V (6 chapters) covers assorted extra topics, such as OLE and Active X integration and performance tuning. Part VI is a set of nine farily detailed exercises (with source code on the provided CD).

This book is not an overview, the authors opted instead to cover certain topics in pretty good depth. This aproach is good for those already aware of the basic concepts, but will be confusing for noobies (which I was when I first got it). I suggest that those new to Eclipse plug-in development start with a good overview (such as _Eclipse 3 for Java Developers_ by Daum) before switching over to this book for more detailed descriptions.

This book doesn't cover the Eclipse Modeling Framework or the Eclipse Graphical Editing Framework, probably because each of these is a book in itself. This book is also light on its coverage of SWT and JFace, which you will need to be familiar with to develop your own plug-ins (again, a book-length subject in its own right). You will also want to be thoroughly familiar with Java Design Patterns and best practices, since Eclipse uses practically every design pattern you've ever heard of.

While there have been changes to Eclipse since the Second Edtion came out, I was able to figure it out and map between the examples in the book and Eclipse 3.2.1 without too much trouble.

The first edition was simply great. Not only that it was the first book to describe how to write an Eclipse plugin, it still would be the best -- if Eclipse had stand still. The second edition is not too bad. But the chapter on writing a text editor plugin is so superficial that it could have been left out. Where the first edition described in (necessary detail) how to write a text editor plugin, the second edition just roughly describes the concepts, but no API usage, no example in the book's text. The code on the accompanying CD is somewhat better, but now (2006) partially out of date as well. So if you want to write a text editor, there currently is no book or article I am aware of, that really helps you. You have to dig through existing code and try to find out for youself, why things are as they are.

Finally, the first part of the book on how to use Eclipse could have been removed (~20% of the book) and the chapters on how to write plugins should have been enhanced.

Like many others I wanted to extend Eclipse so I can be more productive. Unfortunately I found this book to be poorly written and the technical details vague. I know what I want to do, but the book (over 1000 pages) does not show me how?!

It explains the Eclipse architecture and idea goals which is fine but is repeated over and over again in various chapters of the book. I also could not get a handle on how it can be applied. This is not a practical guide to Eclipse. It is more about Eclipse's internal design which for most people is a waste of time. The online documents are more useful.

Note the book is also out of date. I tried to follow some of their sparse examples, but I quickly realized it's a waste of time because I have the latest Eclipse 3.11 installed and the examples were for Eclipse 3.0 and the menu options and API have changed. All in all, this book was a real let down.

The book composes of 6 parts.

Part 1 fouces on how to use the Eclipse IDE. The authors do a good job in explaining how to use the Eclipse IDE. Once a while, you will pick up some tricks that you will find extremely useful. Unfortunately, it also explains things that seems obvious from the UI perspective. In short, you read through 10 lines to get one line of useful information.

Part 6 are the exercises that illustrates some simple concepts discussed in the previous section. That part does a pretty good job also.

The other 4 parts discuss how to extend Eclips IDE and to write Rich Client application. Unfortunately, the authors fail miserable in organizing the information. I am expecting the authors will first explain the basic concepts and then start with some simple application and then build on that.

Unfortunately, the first few chapters in those parts does a very poor job to give you a comprehensive overview. Then the authors will get into details that will make you completely lost. The worst part is that when they are getting into details, the section will fill with a lot of "forward looking" statements like do not worry about some details which will explain in later chapter. Sometimes, you will find that if they reverse the order of the chapters, it may be easier for you to understand.

This book definitely needs a better Editor to make the information more coherent, and to condense the information better. The authors should re-organize the chapters/information to start from building a simple application with a window compose of a few views and some manual items.

The book is very good. The problem is the examples. The examples are all heavily loaded and compounded. Like when you want to learn a certain type of a tree, instead you will be put into a dense forest and lost totally. I do not recomend the beginner to start with this book. I want the author to redesign the examples so that the topic be focused.

Discover WTP, the New End-to-End Toolset for Java-Based Web Development

The Eclipse Web Tools Platform (WTP) seamlessly integrates all the tools today�fs Java Web developer needs. WTP is both an unprecedented Open Source resource for working developers and a powerful foundation for state-of-the-art commercial products.

Eclipse Web Tools Platform offers in-depth descriptions of every tool included in WTP, introducing powerful capabilities never before available in Eclipse. The authors cover the entire Web development process�|from defining Web application architectures and development processes through testing and beyond. And if you�fre seeking to extend WTP, this book provides an introduction to the platform�fs rich APIs. The book also

• Presents step-by-step coverage of developing persistence, business logic, and presentation tiers with WTP and Java
• Introduces best practices for multiple styles of Web and Java EE development
• Demonstrates JDBC database access and configuration
• Shows how to configure application servers for use with WTP
• Walks through creating Web service application interfaces
• Covers automated testing with JUnit and Cactus, and automated builds utilizing Ant, Maven, and CruiseControl
• Introduces testing and profiling Web applications with the Eclipse Test and Performance Tools Platform (TPTP) project
• Describes how to extend WTP with new servers, file types, and WSDL extensions

Foreword
Preface
Acknowledgments
About the Authors
Part I: Getting Started
Chapter 1: Introduction
Chapter 2: About the Eclipse Web Tools Platform Project
Chapter 3: Quick Tour
Chapter 4: Setting Up Your Workspace
Part II: Java Web Application Development
Chapter 5: Web Application Architecture and Design
Chapter 6: Organizing Your Development Project
Chapter 7: The Presentation Tier
Chapter 8: The Business Logic Tier
Chapter 9: The Persistence Tier
Chapter 10: Web Services
Chapter 11: Testing
Part III: Extending WTP
Chapter 12: Adding New Servers
Chapter 13: Supporting New File Types
Chapter 14: Creating WSDL Extensions
Chapter 15: Customizing Resource Resolution
Part IV: Products and Plans
Chapter 16: Other Web Tools Based on Eclipse
Chapter 17: The Road Ahead
Glossary�|
References
Index

This book is an invaluable resource for every Eclipse and enterprise Java Web developer: both those who use Eclipse to build other Web applications, and those who build Eclipse technologies into their own products.

Complete source code examples are available at www.eclipsewtp.org.

To give a brief background about myself. I have been one of the primary contributor and committer of the Web Tools Platform (WTP) eclipse tools project since its inception through WTP 1.5 release. I contributed the Validation Framework component for this project. I read a large portion of this book and can say that this most comprehensive book that explains the complete WTP in a step by step fashion that can be help you easily understand the whole WTP project, its sub projects, its components and features through several real world examples. I strongly recommend this book to all users and contributors of WTP.

Vijay Bhadriraju, IBM

Eclipse Web Tools Platform: Developing Java(TM) Web Applications

This is an excellent book; I specially liked the iterative approach (for example, for presentation tier, iteration 1: HTML, iteration 2: add CSS, iteration 3: add Javascripts, iteration 4: XML and XSLT, iteration 5: DTD)authors have taken. I have used examples from this book, with Eclipse and NetBeans, of course for Eclipse user this book has added value, since it goes through configuration of Eclipse and recommended practices. Please ignore the gripe about errors in the code; there are two minor errors which are detailed in the errata on book's companion site, it doesn't take more than a minute to fix those two issues.

Authors discuss All three tiers in great detail. How about this, by page 85 you would be deploying a simple web service (and you would be amazed how simple it is).

Though I have had some experience in Java, Eclipse, and WTP, a recent project required me to get more into depth. This book got me through the whole development process. It explained to me clean coding techniques when writing web apps in Java, how to get my web server up and running for use with WTP, to get my apps to talk to the server, debugging using different tools, and unit testing in a web environment.

This book was an invaluable addition to my collection, and is also a great reference now that I have mastered these concepts.

Agile Java�� Development With Spring, Hibernate and Eclipse is a book about robust technologies and effective methods which help bring simplicity back into the world of enterprise Java development. The three key technologies covered in this book, the Spring Framework, Hibernate and Eclipse, help reduce the complexity of enterprise Java development significantly. Furthermore, these technologies enable plain old Java objects (POJOs) to be deployed in light-weight containers versus heavy-handed remote objects that require heavy EJB containers. This book also extensively covers technologies such as Ant, JUnit, JSP tag libraries and touches upon other areas such as such logging, GUI based debugging, monitoring using JMX, job scheduling, emailing, and more. Also, Extreme Programming (XP), Agile Model Driven Development (AMDD) and refactoring are methods that can expedite the software development projects by reducing the amount of up front requirements and design; hence these methods are embedded throughout the book but with just enough details and examples to not sidetrack the focus of this book. In addition, this book contains well separated, subjective material (opinion sidebars), comic illustrations, tips and tricks, all of which provide real-world and practical perspectives on relevant topics. Last but not least, this book demonstrates the complete lifecycle by building and following a sample application, chapter-by-chapter, starting from conceptualization to production using the technology and processes covered in this book. In summary, by using the technologies and methods covered in this book, the reader will be able to effectively develop enterprise-class Java applications, in an agile manner!

�|

�|

I felt like the book basically defines terminology and gives a broad overview of the three technologies. I agree with the reviews that said he tried to do too much, in this book. One solution would have been to drop the Eclipse section, thus giving him more space to write about Hibernate and Spring. Besides everything about Eclipse is well documented, for free. I also agree with the reviews that did not like his writing style. I feel that when I am just begining to learn about something new, I don't want to read about all of the exceptions. Only after I know the basics, would the exceptions be helpfull. However, I did get enough general information to begin learning Hibernate and Spring, through other books. That in combination with the fact that the book was heavily discounted, enabled me to feel like I didn't do too bad. I am afraid if I would have paid full price I might have dropped the rating to one star. The cost benefit ratio would have been different.

This book tries to cover too many things. The book is more a Manifesto for Agile Development from an experienced programmer than a technical book.

Thus this small book misses all the details any technical person would like to see. The book is definitely not a comprehensive API guide to Spring or Hibernate, nor does it intend to be. The author repeatedly said : "more to come later" or "we'll see this in later chapter" etc. But that moment never arrived...

The books can be used to get an overall idea for a manager or a programmer who is totally a newbie to the concepts.

The more interesting part is on Agile Development where it seems to be a Manifesto but definitely not a tutorial.

I can not believe how anybody who has read this book would honestly give it a 5 star. I read the whole book, waiting for that moment that I could say: Oh, that's what the author meant by repeatedly saying: "more to come later" or "we'll see this in later chapter" etc. That moment never arrived. This book looks like a hurried and lousy compilation of 5 day presentations on each subject that this books claims to cover, without proper editing and attention to detail.
I read the book riding the metro in Washington DC and I can honestly say that I would rather see DC tourists block the left side of the escalators in the metro stations on a busy rush hour day than read or refer to this book again

Somewhere in the initial few pages, the author give his readers a few options before reading (or buying for that matter) this book. One of them was to trust his advice, agree that Spring+Hibernate+Eclipse are cool technologies and scrap the idea of this book.

I continued reading but now I recommend accepting his idea and save some bucks or buy something more useful, maybe separate books on Spring and Hibernate (btw, Spring in Action 2nd Edition is now available). All of these are surely good technologies but the book never goes into detail of any one of them (and it was not supposed to) and for installation/setup refers you to "latest installation instructions".

Without the depth of details on any particular technology, and lack of instructions on making you up and running makes this book feasible only for a small window of people who want to try out and be "convinced" themselves personally before eventually buying separate books on each technology.

I did not comment on the content because content comes after the 'purpose' of the book. For me its a two-star book and does not even require a content review (read other reviews for content if you really want to buy this).

I like the concept of this book. Combining a whole bunch of ideas that these days are well proven and likely to result in well written software and productivity gains.

Agile, Java, Eclipse, Hibernate, Spring. All stuff that I am working with right now. Seems the perfect book to fill in the gaps in my current knowledge.

Unfortunately, though the author may be a fine developer, he is not a great writer. This book to me had serious flaws, and unfortunately, I learnt oh so little.

The book barely scratches the surface, glossing over any real detail and bringing not much more than what you'd get reading the home page of the respective products.

Some may like the ultra-casual writing style, but I found all his diversions and personal asides distracting. Granted, it's easy to read when the writing resembles that of a spoken conversation. But I found the book to be disorganised, fragmented, and having a rushed quality to it. And just too lacking in depth.

I realise that the author was attempting to cover a lot of ground (as he points out more than once) but this book could have been so much more concise. For example, he wastes his (and my) time reviewing alternative IDEs when already admitting he is totally smitten with Eclipse. If the author just hadn't been so keen on personal asides and spent a bit more time getting the structure of the book right, he could have covered the subject matter in much more detail.

OK, so this book might be good if you want a crash-course in all those fantastic open source products. It might save you some time in getting your basic application up and running, if you've never used any of these products before. But if you're already familiar with them, or don't mind reading some online documentation, or don't mind having a quick play yourself, then your hard earned cash may be more wisely spent elsewhere.

Java programmers know how finicky Java can be to work with. An omitted semi-colon or the slightest typo will cause the Java command-line compiler to spew pages of annoying error messages across your screen. And it doesn't fix them--that's up to you: fix them, compile again, and hope that nothing goes wrong this time.

Eclipse, the popular Java integrated development environment (IDE) provides an elegant and powerful remedy for this common, frustrating scenario. It doesn't just catch your errors before you compile, it also suggests solutions. All you need to do is point and click. And it's free--what could be better? Still, if you're like most programmers, mastering a new technology--no matter how productive it will make you in the long run--is going to take a chunk out of your productivity now. You want to get up to speed quickly without sacrificing efficiency.

O'Reilly's new guide to the technology, "Eclipse," provides exactly what you're looking for: a fast-track approach to mastery of Eclipse. This insightful, hands-on book delivers clear and concise coverage, with no fluff, that gets down to business immediately. The book is tightly focused, covering all aspects of Eclipse: the menus, preferences, views, perspectives, editors, team and debugging techniques, and how they're used every day by thousands of developers. Development of practical skills is emphasized with dozens of examples presented throughout the book.

From cover-to-cover, the book is pure Eclipse, covering hundreds of techniques beginning with the most basic Java development through creating your own plug-in editors for the Eclipse environment. Some of the topics you'll learn about include:

Using Eclipseto develop Java code

Testing and debugging

Working in teams using CVS

Building Eclipse projects using Ant

The Standard Widget Toolkit (SWT)

Web development

Developing Struts applications with Eclipse

From basics to advanced topics, "Eclipse" takes you through the fundamentals of Eclipse and more. You may be an Eclipse novice when you pick up the book, but you'll be a pro by the time you've finished.

I agree with most of the other reviews the book is a little disjointed but it does a better job of explaining Eclipse than the confusing on-line documentation. However I was a very disappointed that it did not cover any of the CDT (the C/C++ development tool) which in my opinion is just as important as the JDT (Java development tool) I switched to eclipse in order to have a common cross platform editor for Linux/Windows/OSX and I also wanted that for cross language development but the CDT was never touched upon.. grumble grumble...

I found this book very helpful in navigating through Eclipse. Be sure to check which version of Eclipse you have; there are differences that can lead to confusion for first time users.

I stumbled onto Eclipse from a very unorthodox path. In my concurrent Java programming unit I continued to have problem in getting students to address all issues of import in their assignments. I thought that I should write a progressive series of programs to address one issue at a time. In class we were relying on command line compilation and execution of the Java programs.

To develop Java programs, I downloaded Eclipse IDE and started to write programs one project for each set of progressed specifications. Soon I had some 10 projects with 10 sets of codes. Eclipse was great, it allowed me to debug and see activities even in multi-threaded execution of programs. However, I wanted to have some transition among my 10 projects to be smooth. I wanted to use consistent interfaces, shared code for classes and comments. I wanted to learn more on refactoring functionality of the IDE. I bought the book to fill this goal.

Have not found much to help my goal but the book has exposed me GUI builder ideas V4ALL. But this project seem to be already gone. SWT was also a new exposure. I have not yet explored it but would it be acceptable replacement for Swing for a university course?

Over all the book is nice and easy introduction to using Eclipse IDE but much of what it introduces can easily be learned from the Eclipse help, tutorials and commonsense. It is time that the author be magnanimous and put the book on Web for all Eclipse beginners to read and adapt the tool. Good book but I am not sure if I can ask my students to spend money on purchasing a copy. An update to reflect the current state of the IDE would also be welcome.

Time has started to diminish the value of this book. Chapters 6, 7, and 8 deal with building GUIs using the V4ALL Eclipse plugin, which is now classified as Obsolete. Also with Eclipse 3.3 now available (the book focuses on Eclipse 3.0), a new edition of the book is definitely needed.

I bought this book and have been making my way through it to teach myself about Eclipse. I did fine for the first five chapters, but after that the trail grows cold because the book is based on Eclipse prior to the 3.0 and later releases. I began having lots of problems because the instructions and screen shots no longer came close to matching what is actually in Eclipse 3.0. So I gave up after chapter five.