5 comments about The JavaScript Anthology: 101 Essential Tips, Tricks & Hacks.

1. It is a good book with useful tips and tricks.
   the authors use an elegant way to catch the target.



2. I didn't really think I needed this book -- I have sever other JavaScript books, including the O'Reilly JavaScript Cookbook, and it seemed like this would just be a duplication. But I kept reading really positive reviews of this and other SitePoint books on sites that I trusted, so I decided to take a flier on it.
   
   I'm really glad I did. Unlike some of the O'Reilly books, which are dated at this point, this has really up-to-date, professional code that incorporates best practices. Depending on what kind of JavaScript code base you need to integrate with, you may be able to use this code as-is in many instances. Even if you need to modify it for your own uses, you will never find poorly-organized hackwork here.
   
   Also nice is the up-to-date topic selection. Classics like DOM, form validation, drop-down menus, and cookies are supplemented with topics about accessibility, XMLHttpRequest, in-page dialogs, and using class prototypes. When the authors tell you how to launch popups, they also tell you about all the pitfalls and problems.
   
   No cookbook is going to cover ever possible topic (personally, I would have liked to see JSON examples), but this one is about as complete as you could reasonably ask for. Really, the only downside about this book that I can see is that you need to have at least an intermediate understanding of JavaScript to understand what's going on. There isn't a lot of handholding, and you will likely want to own both a good tutorial and a solid reference on JavaScript and spend some time with them before you're ready for this book. But if you have a good working knowledge of JavaScript and are looking for practical, well-written examples of how to incorporate new techniques into your code, you won't find a better book than this one.



3. This is an excellent next-step up from an introduction to Javascript and looks at its use in real world situations. You will need to be reasonably fluent in the language to get the best out of it.
   
   The book presents a topic as a question and then presents code to action that query as a solution, then goes through that code in a discussion section. This is where I have a relatively minor criticism of this book; the necessities of discussing the code do not always mesh well with the question and answer format of the layout.
   
   The authors have gone to great effort to ensure that the book is as up-to-date as possible, though this is a rapidly moving target of course, and detail how to ensure that the code will run on as many platforms as possible, rarely giving up and saying 'forget it..', though this proved necessary in a number of the more esoteric options and older browsers.
   
   A highly recommended read if you are looking for a quick solution, or a detailed understanding of what's going on.



4. I purchased this book out of desperation after using a 1000 page Javascript Wrox book published in 2000 that was worse than useless. The author's blog posting here is very accurate: it is a modern javascript book that gives usable solutions and concepts that work well. I recommend this book to anyone who has at least some programming background and is sick of cut and pasting garbage code from other mickey mouse tutorial sites that break at the slightest change. It is also a great start for working with AJAX, which is what I needed it for.
   
   That said, the book is surprisingly a great read. I am reading this book cover to cover and also use it as an every day reference with dozens of tips. It is obvious the authors have worked extensively with web sites and write from experience. Thanks for a job well done!



5. I should preface my review by saying that I generally love the sitepoint books. Simply Javascript (also co-authored by Adams) is hands down the best programming book I've ever read. That said, this book isn't really so much a "book" as it is a "handy reference." If you skim this book and find something you need, then you may be able to justify the cost. As a cover-to-cover read, it's definitely lacking and will leave you wanting. Taken as individual chapters, the writing is excellent and the solutions offer solid coding practices. My recommendation would be to find this book in a bookstore, skim the table of contents and chapters, and see if you will actually use any of the included solutions before you buy.

2 comments about Pro Netbeans IDE 6 Rich Client Platform Edition (Expert's Voice in Java).

1. I've bought this book hoping that it'll help me use the "platform", i.e. a set of reusable components that Netbeans itself is built with, to write my own app.
   
   Instead the book is basically a shrunk paper based version of the Netbean's own help.
   
   Absolutely worthless. Definitely returning it.



2. Eagerly anticpated book that was utterly disappointing. I had decided to make Net Beans my IDE of choice, but because of the lack of good documentation (including this book) I am going back to [...]

5 comments about Java Concepts.

1. An excellent intro to programming from an outstanding author and programmer. It keeps reasonably upto date with the latest java version and presentation trends (pages are so full of color that reading it reminds me of a kid's birthday party.. personally I hate it, but it seems that's the current fashion..). My only problem with this book is its price and outrageous selling strategy. This book, as well as Big C++ and Big Java sell for 80 to 90 bucks in the US, where they can be imposed to college students as textbooks. Here in Italy, where this trick can't work they sell for their real value, that is from 40 to 50 bucks.
   So, exploiting the enthusiasm of the student buying his new textbooks (I know how it feels I have been there myself) or just the plain fact that it can be imposed as required reading in some classes this text is oversold at almost double its real market value. I find this disgusting. Unless you are forced to adopt this text, go for a maybe less academical and colorful book (but reasonably priced ) by the same author, Core Java.



2. I use this text for an AP Computer Science course, and find it to be one of the most confusing books on the topiic of Java and Computer Science. Being in multiple APs, I obvisouly cannot read every single word and frequently have to sort out what information is relevant in a book. In most of my textbooks, this is rather easy. Horstmann's book is, however, quite the exception. The authos literally interupts his own sentences and sections with dozens of "Random facts," "Productivity Hints," "Advanced Topics," and many more of these litte interuptions. One chapter, I forget which one, actually has three of these strung in a row, manking this book incredibly hard to read. After cutting out in the middle of a topic, it is very common to just, without warning, start back up five pages later. Avoid this book.



3. This text is a nightmare. Terms are poorly defined, if defined at all, and examples are few and far between. The illustrations are laughable. I've seen better graphics in nursery books written 30 years ago. If your professor assigns this text, and you're new to Java, be prepared to shell out more bucks for better sources or cruise the Internet to get the answers you need. This book won't provide them.



4. If you've read "The C Programming Language" and enjoyed the style of its presentation, you'll likely find this book appalling. The book is neither concise, nor lucid; you wade your way through endless explaination and come out with little understanding. I've found the examples and the presentation on Sun's website to be much easier to understand, simply because they start with a clear example, discuss it a bit, then give the details of each statement (much like Kernighan's book).
   
   Also, some of the code can't simply be typed in and compiled. In one section, they fail to mention, either in the text or in the example, that you need to import a certain class. The documentation on Sun's website is excellent, but that shouldn't make it acceptable to leave details out of the text.
   
   Finally, the price is a total rip-off. I was fortunate enough to get the book used for under $20, but I would feel cheated if I had paid more. A lot of the information can be gotten for free, and that the quality of the free information often exceeds that which is in the book. Sadly, this book seems to fit the "intro to programming" niche, and a lot of students will be forced to buy it for those classes, allowing the publisher to get away with the high price.



5. There are lots of people dissatisfied with this book, myself included. I really don't understand how anyone can find this book cohesive, and the little bit of information you get out of it you have to dissect the text for hours to get any meaning from it. This book loves to give you code to use and not tell you what in the world it does, just that you need it. So you use it for chapters then boom, in chapter 9 your finally tells something about it. That is not constructive. The learning process does not work this way. Most of the time the book hardly tells you anything. You can see that certain things must come before others, but not told why and with out being told what the code really does; its mostly just guessing why. I understand that the goal of the book is to teach programming and not a specific language, but this book does not successfully do that when it doesn't tell you what is going on. In my opinion, it confuses you to what is going on and you have to "unthink" what you've learned to actually progress with another book. I gave up completely on the book for my class and turned to outside sources to pass. Most of my classmates have been forced to do the same.

5 comments about Java Software Solutions (Java 5.0 version): Foundations of Program Design (4th Edition) (Lewis Series).

1. It has a pretty good presentation, with all the colour and everything. However, I seriously think this book is too simple. It is meant for the absolute beginner to programming, with plenty of examples for a good foundation.

   With some programming experience under my belt, I found the first few chapters agonisingly slow. It does a decent job of describing the Java language fundamentals, however, and I especially liked the appendix with the Java class libraries. Other books often lack this and sometimes when a code segment in the text refers to some class, and I desperately want to know more about it, I have to open my browser and read the API specifications, which can be quite annoying.

   All that said, remember that when they say foundations of program design, they mean FOUNDATIONS, as in the very basics.




2. This book is the core textbook for a computer programming class that I am taking and it is definitely one of the best textbooks I have read. The ideas are presented in a very clear, simple and easy to digest way, and the high quality graphics also make the material easy to absorb visually. It seems like the whole focus of the authors is to make sure the reader learns and understands Java.

   I did read two other introduction to Java books that cost less and got strong reviews. However, they were not nearly as effective. If you truly want to learn Java and have some fun in the process, I highly recommend this book.




3. The book is clearly directed at a reader new to Java. She might also be new to programming, in any language. Consequently, the book steps carefully through various key ideas, like object oriented programming, polymorphism and recursion. These, and other ideas, are reinforced by extensive self review questions and problem sets. Something worth considering by a lecturer searching for a text to accompany a course.
   
   It is good that the graphics examples focus on using Swing widgets. The original AWT widgets get only a passing remark. Which helps a newbie avoid coding in these.
   
   The book has extensive appendices. Too extensive. Appendix M, which lists the Java class library, is superfluous. It describes the standard Java classes that come with J2SE. For each class, it lists the variables and constants, constructors and methods. Along with brief explanations of the intent of many of these items. The Appendix takes up almost 160 pages. A sizeable fraction of the 900 pages of the entire book. The problem is that the appendix is basically a rendition of the standard documentation that Sun supplies with Java. Little value is added by Lewis and Loftus. This appendix should have been entirely dropped. Instead, the reader could have been directed to the appropriate Sun URL. Or, indeed, been asked to search the web. Because it turns out that the manual pages written by Sun are widely mirrored by many websites.
   
   Or, the manual pages should have been in the CD that comes with the book. (If the pages are already on the CD, then Appendix M should certainly not have been written.)



4. This book could have shown the examples, especially the complicated ones, a lot more in depth. The basic information of the book is good, but it is very dry. The chapter on recursion is not very helpful at all. The author could also make better examples for exception handling.



5. There is an updated printing of this book that uses ISBN 0-321-32202-7. The updated printing (which corrects small changes in the final version of Java 5) also is called the 4th edition. The publisher added words "Java 5.0 Version" to the title listed in online stores, and added a leaf with the words "Covers Java 5.0" to the bottom right of the cover. Be sure not to buy an old printing that you can't return, especially from someone selling a used copy.
   
   This URL to purchase the most up-to-date printing from Amazon is: http://www.amazon.com/exec/obidos/tg/detail/-/0321322037/qid=1126549578/sr=8-2/ref=sr_8_xs_ap_i2_xgl14/102-3991796-1688157?v=glance&s=books&n=507846

5 comments about Hibernate: A Developer's Notebook.

1. For the versions of Hibernate and Hsqldb it was written for this is an excellent book to get you up and running, and a good introduction into the Hibernate platform.
   But Hibernate and Hsqldb both have moved on and many (most) of the examples no longer work without modification.
   Nothing that searching the web and Hibernate documentation can't find quickly though, leaving it still a viable introduction into the concepts and syntax.
   
   I personally like thin books and this one certainly doesn't try to spoonfeed you Java or anything, it assumes the reader is smart enough to figure things out for himself.



2. Yes...
   i just got it yesterday and brought it to work and it helped me solve an issue that has been buggin me since 2 days ago!
   
   The examples seem to be quiet easy to read and the format is basically what a developer would ask very intuitive.



3. I purchased this book when it first came out, and this past weekend finally got around to doing all of the examples. I suggest downloading Hibernate2, which is what the book covers. Hibernate3 is a bit different in structure and will just slow down what you are trying to learn.
   
   Needless to say 2 days later I am building my backend with Hibernate and upset with myself that I did not read and study this book a year go.
   
   I do suggest getting a nice Hibernate reference book on top of this. This book will get you started nicely (by chapter 2 I was on my way), but it would be of value to understand more of the details.



4. not only is this book pretty outdated as it only focuses on hibernate2 and not the newer release hibernate3 which is not backwards compatible... there was also a "serious technical error" early on in the book that set me back a while... google the corrections if you use this book.
   
   the writing style was decent... i wouldn't mind reading an newer updated copy



5. When doing projects that use mapping files, everyone gets a copy of this book. It is exactly what it is - a good handbook about Hibernate.
   
   The only drawback to this book is that it covers only mapping files, without any focus on annotations.

5 comments about Pro JSF and Ajax: Building Rich Internet Components (Pro).

1. The authors begin "This book is not, and we would like to emphasize this, not an introductory level book..." That's for certain. Except for quick review material in the first chapter, the authors move quickly into a project that assumes a good amount of experience.
   
   The book effectively follows a pattern that you have seen before. Build a simple component, integrate it, then progressively build in functionality and complexity while dealing with usability and maintainability issues.
   
   One factor that makes this book stand out is the great number of flow diagrams. This book has the expected code printouts and screenshots but the extra emphasis on logic diagrams is exceptional. Also not seen in other JSF books are two chapters on providing Mozilla XUL and Microsoft .htc renderers. Yes, the last is a bit of a surprise!



2. If you already have a background in JavaServer Faces (JSF) and you want to start exploring the integration of that with some of the Web 2.0 technologies, Jonas Jacobi and John R. Fallows have a book that might interest you... Pro JSF and Ajax - Building Rich Internet Components.
   
   Contents:
   Part 1 - Developing Smarter with JavaServer Faces: The Foundation of JSF - Components; Defining the Date Field Component; Defining the Deck Component
   Part 2 - Designing Rich Internet Components: Using Rich Internet Technologies; Loading Resources with Weblets; Ajax Enabling the Deck Component; Ajax Enabling the Date Field Component; Providing Mozilla XUL Renderers; Providing Microsoft HTC Renderers; Switching RenderKits Dynamically
   Index
   
   To be honest, this book was beyond my current technology level. While there is a brief overview of JSF technology, you'll get the most out of the book if you already have a relatively solid grounding in it. They use two components, the Date Field and the Deck components, to show how JSF can be used to build internet application components that are able to be reused in other applications. The real value comes in Part 2, where they take those two components and start mixing them up with technologies that allow for rich internet functionality, such as Ajax and XUL. Using the examples provided, you start to see how a JSF application mixed with something like Ajax allows you to start building internet applications that behave more like desktop client apps... no round-trips to the server... no constant screen refreshes to get new content... Pretty cool stuff. I'd also recommend that you be pretty conversant with the rich internet technology already. Like with JSF, there's an assumption that you already understand the basics, so don't think that your first exposure to Ajax could be with this book. You'll be in pain if you try that route...
   
   If you've had the exposure and you're now looking for some really cool project on which to apply your JSF skills, this could easily be the book that helps you make that transition from "Hello World" to "ooooohhh..."



3. I tried reading the first chapter, got through half and realized that the overview was simply hitting the architecture big picture with no code (this is after reading the complete reference cover to cover) -- skipped to the second chapter cause I had no clue where the author was at on chapter 1. Chapter 2, trying to describe component extensions -- the code examples had a bunch of css. CSS? And no mention that css was a part or not a part of jsf. To someone without a design background this would be very confusing. Huh? Why? To take up space that's why.
   
   This is a worthless book that obfuscates. My opinion, they put this thing together to capitalize on the hype surrounding jsf and ajax with no clue as to how to actually teach how to integrate the two. Finally the most annoying thing is about half of the copy starts out "in this chapter you will ... " then some worthless unrelated code and then another section with "in this chapter you will ..." Waste of my precious time and mental space to read this book. They should take a hint from NIKE and just do it rather than talk about it. CODE... examples and more code -- I don't want to read or waste time reading "in this chapter you will"...



4. Even for an advanced developer/architect this book does not make sense. There are too many typos, wrong references to Figures and Tables, and confusing diagrams. On the top of all these things, it is poorly written. For example (Verbatim from chapter 2):
   
   Figure -1 shows the five classes you'11 create in this chapter, they are HtmlInputDateRenderer,ProInputData,UIComponentTagSupport,and ProInputDateTag, as well as two you'11 be extending Renderer and UIInput.
   
   As you can tell from the above the author is quite confusing.



5. I bought this book looking for examples on how to create custom JSF components and AJAX or extend existing components. The book is very light on this. It starts with a general overview of the JSF life cycle. Chapter 2 shows you how to create a date component and chapter 3 a deck component. Unfortunately the information is scattered and does not flow very well. Part 2 of the book has very little to do with JSF. Explains what Rich internet technologies then it give other examples of Rich Technologies which don't help you in developing JSF components It even goes into Microsoft technologies
   This book would be better with more JSF/AJAX examples and less fluff. They try to bring you from entry level knowledge to expert knowledge. If I wish to create JSF components I have been using JSF and the components available to me are limit so when I buy a book like this I do not want to start at the beginning and I am not interested in other technologies that are similar to JSF like XUL, Weblets and Microsoft HTC I have choose my technology when I come to a book like this. If you want a general high level overview this book covering technologies besides JSF this book is ok. If you want and indebt book about creating JSF components with AJAX this is not it.

5 comments about JavaScript: Your Visual Blueprint for Building Dynamic Web Pages, 2nd Edition.

1. Updated:
   The publisher has now provided me with a corrected copy so I would like to update on my negative remarks made previously. This an excellent book for beginning JavaScript programmers and it also makes a good reference (or cookbook) for experienced programmers. If you need a jumpstart into the world of clientside scripting this is the book I recommend. Give it 5 stars now.
   
   
   [Old review: I have just received this book in its first printing of the 2nd edition.
   Unfortunately the publishers have let the author down badly.
   This book would have rated 5 stars from me if it did not contain bad printing errors which cause most of example code in the diagrams to be invisible.
   Hold off on this one until the next corrected printing.]



2. I bought this book and it had some printing errors, but I contacted the publisher and got a new copy overnight. They have fixed the problem since so I don't believe you will find the same issue. If you like learning step-by-step, this is the book for you. Easy to follow and great for some new to Javascript. The book is well organized and explaines javascript concepts in quick concise explainations. All of the examples are easy to follow and focus on one topic at a time.



3. Please note that the printing issue has been fixed in all available product. Any future books shipped will have correct text and code.
   Thank you.



4. This is a decent book on JavaScript. The format consists of a detailed explanation of a concept or technique then example code. It's filled with many useful examples both large and small. This book has a lot of good information and probably could have benefited from being a bit longer. Many areas were covered including event handling, debugging and objects. There was also a great chapter on cascading style sheets (Probably just a setup for the next chapter on DHTML).
   
   The code is displayed using screens shots of the code in a notepad window on the author's computer. At times it was difficult getting the whole picture of the code across multiple screen shots. It was sometimes difficult reading and typing code from these screen shots as well. I had a lot of errors because I couldn't tell the difference between a single and double quote or between a comma and period. This was more of a problem with the lengthier scripts. Also, the order of the chapters wasn't very helpful either since many concepts were used in early chapters but not explained until a later chapter.
   
   This book is definitely more of a reference than a book on actually teaching the fundamentals of the language. Though as a reference it has far fewer pages compared to a code bible or cookbook. It's probably better for someone who wants to cut and paste code or is already fairly fluent in another programming/scripting language.



5. As someone else noted, the examples are in tiny type.
   
   More seriously, I found the examples to be hard to follow because of overly-similar variable names and unnecessary complexity. Often tries to show several concepts combined in one long example instead of one short example for each.
   
   Good concept but trying to cram too much material into too few pages.

2 comments about Java: An Eventful Approach.

1. The authors have taken an interestingly different pedagogy to teaching Java to someone totally new to it, or indeed new to any programming language. Most texts on Java start off with describing the simple syntax, like for performing arithmetic, or inputting or outputting a string. These must necessarily be done within at least one class, since Java is very strict about this. But this approach is essentially the same as for earlier non-object oriented languages like C or Fortran. Typically, only later in such a Java text will object oriented discussions arise, or the use of graphics.
   
   The novelty offered in this text is to emphasise from the very first chapter the object oriented nature of Java. This is aided by the use of graphics classes. The authors chose graphics because these give an immediate visual feedback to the student, that is very intuitive. This tight feedback loop can aid understanding or even the interest of the student. The two issues are often related!
   
   Also, they do the student a favour by simplifying what can admittedly be a confusing melange of associated graphics classes, when you attach a Listener to a Java graphics object. Because then you usually need to write a class that implements that Listener interface, even if you won't be using all the methods. All this is needed under Java. But the authors finesse it by providing a class library which they call objectdraw. It lets the student focus on the key graphics ideas without tripping over the boilerplate. Later in the text, it reveals the usual gory details of what normally has to be done. Hopefully, the student will be experienced enough by then to take this in stride.
   
   Another bonus about this book is that through its examples of an Integrated Development Environment, it encourages the student to adopt the free Eclipse. Thus far, Eclipse has been mostly used by experienced Java professionals. But it has very powerful helper facilities. Pushing it down to new programmers may well help them.



2. It's a good book overall. It offers a more practical approach to object-oriented programming. The fun excercises challenged me enough to make me confident in each lesson. However, because it's only a first edition, there were numerous spelling and syntax mistakes. Nonetheless, I learned an incredible amount about Java and have now found a new hobby.

No comments about Beginning Java Game Programming Second Edition.

5 comments about Java Developer's Guide to Eclipse, The (2nd Edition).

1. 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.



2. 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.



3. 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.



4. 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.



5. 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.