4 comments about Professional Eclipse 3 for Java Developers.

1. There are definitely an abundance of books on Eclipse to choose from. One of the latest additions to the field, Professional Eclipse 3 for Java Developers by Berthold Daum (Wrox) is a nice new choice...
   
   Chapter List: Introduction to Eclipse; Effective Programming with Eclipse; The Art of (Visual) Composition; Organizing Your Code; Project One: Duke Speaks; Project Development; Advanced Topics of Project Development; The SWT Library; JFace; Project Two: Jukebox; Developing Plug-ins for the Eclipse Platform; Developing Your Own Eclipse-Based Products; Project Three: A Spell Checker as an Eclipse Plug-in; The Rich Client Platform; Project Four: The Hex Game as a Rich Client Application; Conclusions and Outlook; Useful Plug-ins for Eclipse; Migrating Projects to a New Eclipse Version; Important Downloads; Bibliography; Index
   
   There are a number of things I liked about this book. For one, it deals with the latest Eclipse release (version 3). Although it's not a major problem to mentally translate text between 2.1 and 3.0, it's still easier to learn if both the book and the student are on the same page. Next, Daum concentrates a lot on practicality. The four projects included in the book cover four of the major types of development you'd face as a Java developer. By using the projects during your learning, you should have a good grasp of Eclipse when you're finished. Finally, I appreciate the coverage of the Rich Client Platform. My personal opinion is that this feature of Eclipse is going to be a very big deal, and this book is one of the few that covers it in any detail.
   
   So, if anyone were to ask me for a recommendation on a book for Eclipse, this book would be among the top of the list. It's good stuff.



2. This book does cover the material for RCP and version 3 so its more up to date than the earlier Eclipse in Action book by Gallardo et al, or the S. Holzner Eclipse book.
   Something I've noticed when many programmers give public talks, like at EclipseCon, is that they skip-over the perspective and context and jump right into coding details.
   
   This book too suffers from the LaundryList problem. Some chapters of Daum's book are more like a big list with only a sentence or two to frame them.
   I appreciate that Daum is being comprehensive and so
   the book comes of a bit like the manual you didn't get when you
   'bought' eclipse. The book is worth having around for reference because its systematic and pretty complete. If you're looking to produce a proof-of-concept application in eclipse this book contains good examples of a stand-alone, plugin, and an rcp apps. This book is helpful in framing what you can learn from experimenting with eclipse.
   Its a good reference book, but if you're lost in the wilderness trying to figure how to structure a larger application this book won't provide the persepective you need.



3. I'm no Java jock, though I have done small projects in it and know it enough to be a Java fan. I downloaded Eclipse and almost immediately was confused by the discrepancies in the tutorial with what I was seeing on the screen, so I bought this book. The introductory chapter alone was enough to give me a broad perspective on where I could go with Eclipse (and SWT and JFace), and the first couple of chapters got me started to the extent where I could easily proceed with my new project, run Junit tests within Eclipse, etc.
   
   I think it's a fine book so far, for a person who already knows the basics of Java but doesn't need to be an expert. I find the whole Eclipse thing to be tremendously exciting, actually.



4. I had hoped to find in this book the things I had not found out between the weeks I was started using Eclipse and the arrival of the book. I thought that it would detail in to the nitty gritty details that cost you hours to find out.
   
   Even though it covers Eclipse it seems more a Java programmer manual. The examples used in the book are a speech synthesis program and some Eclipse plugins. The problem is that way to many pages cover the code of the examples and the way to program them.
   
   If I had wanted to find out about those thing I would have bought a book about that. I wanted a book that told me about Eclipse, not about how to write a program.

No comments about An Introduction to Java Programming and Object-Oriented Application Development.

2 comments about Web Development with Java: Using Hibernate, JSPs and Servlets.

1. The rapid changes in Java web technology have left a morass of outdated books. So it is refreshing to see this book using Java 5 annotations, JSP 2.0 with its EL (expression language), and Hibernate 3 annotations both for validation and for persistence. Unfortunately Spring is not covered, causing home-grown solutions for some things Spring could do. I didn't see any real errors in concepts, but there are gaps and statements that depend on the specific case being considered, where this dependency is not clear. For example, there is a statement on pg. 157 that only Hibernate can set the primary key for a row, but this is only true in the @GeneratedKey case in use in this example.
   
   The helper code has no comments and scanty explanation. Some bad practices are in the code, such as HTML by generation by Java printlns and swallowed exceptions. Of course a teacher can fix up localized problems, so this book could be used in a web apps course, and has almost no competitors for a textbook there. It has questions and "tasks" at the end of each chapter, a first for such books in my experience. It covers the basic user interface techniques you need for a simple web app, and a little about multipage apps and MVC organization. There is nothing about a service API, or any layering in the app.



2. I got my hands on a copy of this book, and I couldn't stop reading it. This books is really well written, its clear and understandable, a very rare feature in J2EE books.
   
   If you are looking for a book to learn the basics of Web Development using Java, this is the one for you, it guides you through complicated concepts such as JSP-Servlets interaction, formerly-cryptic web application directory tree, with so much ease.
   
   I highly recommend this title to all the developers/students/java enthusiasts that want to learn how to do Java Web Programming. Advanced programmers might find it somewhat basic, but still a very good conceptual reference.

No comments about The Definitive Guide to Grails, Second Edition (The Definitive Guide).

No comments about Java Foundations: Introduction to Program Design and Data Structures.

5 comments about Developing Java Web Services: Architecting and Developing Secure Web Services Using Java.

1. The other reviews saying "Repetitve and shallow content" are all 100% true.
   It repeats itself over and over again. Is not only boring but it's also extremely hard to follow.
   I'm an experienced java/jsp developer trying to get into web services, and this book only gave me frustration and disapointment.
   When I started reading this book I thought that WS technologies were very complex and hard to understand. Then I realized the only thing hard to understand is this book.
   
   I'm taking this book back to the store.



2. This book is okay as a starting-point in learning Java web services. It attempts to cover a wide range of topics but fails to expand on some subtleties crucial to the understanding of these topics. One obvious example of this is the distinction between document-literal binding style and document-based web services. The book touchs on both concepts but stops right there without any explanations on how these concepts are related or not related, what are the implications of choosing a binding-style from the perspective of a web services developer or an admin, whether the choice of a binding-style determines the programming model, the API set, etc.
   The authors tend to be loose from time to time with their use of terminologies and concepts. Admittedly, part of this is due to the state of the art of web services itself. That being said, some of the comments in the book are quite confusing and misleading. One example is found on page 454 of the book "JAX-RPC is also a best-fit solution over JAXM ... where high performance ... are defined as the key requirements." This is simply contrary to the common wisdom that loosely-coupled messaging applications usually out-perform their tightly-coupled RPC style counterparts when "performance" is defined as the system throughput. RPC style apps may offer a more predictable response time at the cost of inferior throughput. However, this point was never expanded on with any further information. Similar comments can be found throughout the book.
   The writing style of the book is quite verbose and repetitive. Quite often the same point can be found twice or more in one paragraph.
   With its shortcomings, the book is still a decent introduction to web services. However, I would recommend supplementing with other online sources. There are many wonderful technical articals on SUN's blueprint site, IBM and Oracle's developer communities.



3. Better read the specifications than this book. It is merely a compilation. No attempt has been made to illustrate a single concept. Some times, I wonder whether the authors understood something at all or just wrote the book out of passion to write a book, since there is NO value addition to your understanding. Not worth even a buck.
   
   (...)



4. Don't be fooled from the good reviews this book has gotten. this book is the WRONG choice for anyone willing to LEARN about web services in Java. It is merely a boring, dry, wordy, repetive, confusing (and confused) compilation of web-services related topics.
   The authours might be good programmers maybe, but as they are clearly very poor technical authors.. their writing style is boring, excessively wordy and abstruse.
   Not clear and concise enough to be useful as a reference and absolutely terrible as a tutorial.
   The preface tells how the idea of writing this book came form one of the authors who, sitting in a pub with the others was the the only one who wasn't drinking. I have some advice for this guy: start drinking.



5. I bought this, hoping to be able to use it on a web services project I'm doing.
   
   I find it's completely out of date. Both Sun's JWSDP and Apache Axis have moved on since this was written, and you'll get better information from their websites than you'll get from this book.
   
   Don't bother with it.

5 comments about Pro Apache Struts with Ajax (Expert's Voice in Java).

1. This book got me started with Struts very quickly. I was able to quickly learn the basics and start writing my first struts app. I haven't finished the book yet, but it is already worth the money I paid.



2. I would like to write a longer review but I'm pressed for time so I'll keep it short and sweet.
   
   The authors have created a very easy to follow guide (and reference) for beginning Struts development. I've found it very useful for the project I am working on. A couple of shortcomings...
   
   In the section on Struts form validation, they don't go into how one would handle using ActionForm's validate() method to validate a form when the associated HTML FORM uses [for example] html:optionscollection to present a pulldown with choices. Forwarding to the controller, and an action that could then repopulate the beans with the pulldown values would make sense but I'll have to figure this out on my own to see if that's the way to do it.
   
   Also, nobody responded to my email in which I asked questions about the text. I used the email address from the book but didn't get a response.
   
   All in all, a very good book. Absolutely worth the money.



3. This book, so far, seems to be a fine book about Struts. I am giving this rating to this book for one reason. For an approximately 500 page book, only about 10 pages deal with AJAX. Should AJAX be in the title? I don't think so, one could probably find that much information on the web in a few minutes.



4. There is some decent info on struts, and after searching for information online, I think this book puts stuff together in an easy-to-read and easy-to-follow way. The big downside to me is that the book talks too much about anti-patterns and other design issues that are somewhat ancillary to struts itself. This information isn't necessarily incorrect or even inappropriate for someone learning struts, but my need is to get up to speed quickly on struts and I would rather not see this stuff interspersed with struts itself. Perhaps if the authors feel strongly about covering anti-patterns, it could be done in a couple of self-contained chapters instead of slowing down the rest of the book.



5. This book is fine for learning struts but I was looking for a book on how to combine javascript frameworks like prototype, yui, jquery, with struts.
   
   what is the best coding pratice? to have xmlhttprequests to struts actions that produce html code? xml code? json? or use something like DWR that return your MVC model as javascript objects.
   
   this book doesn't tell you anything about whats the best way to set up your struts controllers / view to use ajax.
   
   wrong title imo

5 comments about Program Development in Java: Abstraction, Specification, and Object-Oriented Design.

1. I have some problems understanding inheritance and other OO terms. This book teach not only the meaning of those term but also teach the advantages and how to use them. After reading this book, i know why those term is very important (inheritance, abstraction, etc) and can use it in my programming life.

   If you'd like to become java expert, buy this book.




2. This is one of the best Computer Science books I have read. It is one of those books where every word is worth reading. And it is so concise. After reading this book, I understood clearly what exceptions were, how good design is done, etc. Also, the fundamental concepts like abstraction, decomposition, etc are so brilliantly described that you will never be hazy about them again. The most favourite topic of mine is the procedural SPECIFICATION part using the REQUIRES, MODIFIES, EFFECTS clauses. It really helped me see how procedures are specified.

   Finally, a word of caution. This is not a book for beginners or for those who are looking for learning Java syntax for writing toy programs. If you have been programming in a OO language (any OO language)for some time and have been using terms like abstraction, design etc without FULLY understanding them, or if you want to learn how to methodically approach the programming process, this book is indispensable!

   Thanks you Prof. Liskov, I learnt so much from your book.




3. Barbara Liskov brings name recogntion the text. Respect comes for reasons, though, and this book shows many good reasons for respecting this educator and her co-author.

   This would be a good book for a second or third course in comptuer science. Even so, seasoned pros should take this book seriously. The reader is assumed to be familiar with basic programming and data structures. The reader is also assumed to be familiar with Java - "development in Java" means that Java is the vehicle, not the topic being taught.

   Techniques in this book are a level above the most concrete. It's premise is that any piece of code must be viewed in many different ways; right and wrong answers are the least of it. The book starts with a simple but rigorous set of commenting conventions - it makes one wish for a truly rigorous programming language. For each method, one specifies its prerequisites or assumptions, the set of objects with state chaged by the method, and the specifics of the change being made. The authors focus clearly on ambiguous specification at this level; explicitly undefined behavior has a valid role in many rigorous designs. This leads naturally to discussion of parameter checking, error handling, and proper use of thrown exceptions.

   The authors develop a few unusual but critical ideas, including mutability - the possibility that an objects data content can change after creation. In well-disciplined programs, this property has far-reaching implications. Liskov and Guttag involve mutability in equality testing, object identity vs. data equality, and valid naming or indexing.

   Encapsulation and data hiding have long been design staples, but the authors' examination keeps the idea fresh. They discuss, from the standpoint of provable correctness, how data exposure puts programs at risk. They also make clear how, viewed with an eye to maintainability, the risks of even read-only exposure of an object's data content. They stop short of discussing true formal verification or industrial practice, though, a decision I think appropriate to the book's level. Readers with deeper knowledge can still appreciate the discussion at its implicitly deeper levels.

   By the time the authors address high-level system specification, it seems almost obvious. Without high-level specification, there would be no way to fill in the more detailed specifications that now come naturally to the reader. The authors also address that tricky moment between specification and implementation: the intuitive process of design.

   Only the end of the book disappointed me, a half-hearted presentation of design patterns. It seems almost perfuctory, presenting DPs just because it's the done thing, not because the authors add their usual depth to the topic.

   I really wish I had more upper-level students and professional colleagues who had been trained according to these authors' program. Their software designs, as students and as professionals, would be stronger and safer if they had.




4. Percect book for a computer science student who must learn the fundemantal concepts of Object Oriented Design (OOD) in order to success and able to design and develop production quality software that are reliable, easy to mantain and modifiable.. It outlines the important steps for each chapter but the order of the chapters should be rearranged.



5. Just don't bother with it. Read Stroustrup all the way through and you'll be better off. If you really MUST do Java, read the online Java docs from Sun, starting with the tutorials. They discuss the same things Liskov does but without the idea of specification.
   
   Use a tool like JavaDoc or Deoxygen consistantly through your program and not only have you gained everything else Liskov discusses, you haven't spent time wading through her, often contradictory, arguments on the subject.
   
   Thats not quite fair, if you really do believe that an Object is a model of something in the real world, and not a clever piece of syntax for expressing your logic and enhancing readibility, than you will very likey LOVE this book.

5 comments about Teach Y ourself Java.

1. A few months ago I decided to teach myself Java. I purchased a few books, and I am happy with my purchase of this book, "Teach Yourself Java".

   After reading more heavy, definition type programmer to programmer java books, this book has been very helpful to return to for a less 'wham to the head' over-view and tie-together.

   On the other hand, this book certainly won't cover it all. To learn java, you are going to need to simultaneusly read multiple books.

   For someone looking to learn java, with little java experience, this book is not a bad purchase.




2. First of all, this book is very well written. The examples are short and very concise. I personally learn by typing the examples and I like them to be short and to the point! This book is also very good from the aspect of not holding you back. It covers very basic control structures through sockets! I also like the fact that there are 394 examples you can download from the web easily. This is definately more ecological. Now some bad ... 1) The 394 examples that can be downloaded are not categorized! BUMMER. You must sift through all of them to figure out which ones apply to your current chapter, although some titles do make this easier. 2) If you are like me and constantly use the index to search for stuff ... you probably won't like this one. 3) Out of 707 pages, 170 of them are dedicated to answering end of chapter questions. That is 24% of the book! I don't consider this a plus. I would have preferred to download answers instead of downloading examples! SUMMERY: This book teaches programming in JAVA without getting bogged down in all the available pre-written web stuff ... although it does cover some web applications. It doesn't hold you back and doesn't assume that you already know a programming language. If you do know C++, you can navigate this book rather quickly and be up and running fast! I'm very happy with this book overall.



3. Mister O'Neil has chosen very effective strategy. Every chapter composed of a short theoretical introduction and working examples demonstrating the theory in practice. Definitely my level of Java programming has been considerably improved after reading this book. I would recommend this book for those readers who want to step up from beginning to intermediate level of Java programming.



4. I was having a hard time understanding Java Exceptions/throw/throws. I read the chapter on Exceptions in this book. The chapter was full of short code examples that makes it easy to understand. I also loved the pre/post quiz and exercises. The writing appears to be very good.
   
   The best Java book for beginners has to be Kathy Sierra's Head First Java. Although, Some think that that should be used as a supplement book. The second best beginner's book is Herb Schildt's beginning java. I would place this book 3rd. I would not purchase Ivor Horton's book or the Java in 24hours. However, Murach's Java 2 is an excellent combination of reference & learning material.



5. This can't be the best book to choose for teaching yourself Java. It's intended to be a learning guide, but it's presented more like a reference. Recognize that part of my frustration is due to my unfamiliarity with object oriented languages. I'm just learning about OOL's, following a long dormant programming history from the 80's, the pre-OOL era. OO programing is significantly different than what I used to do. I'm fascinated with it, but it's going to take some time.
   
   The other major part of my frustration is that much of the explanation text in this book just ain't plain english. It sounds more theoretical. If you're already familiar with OOL's, it probably wouldn't be such a burden. But it's like jumping right into the deep end for me.
   
   I agree with the prior comment that pointed out that the fun stuff (GUI) is at the end. I know you gotta crawl before you can walk, but I think it would keep people's interest better to do something practical and fun along the way.

5 comments about J2EE 1.4: The Big Picture.

1. Sun does a lot of things right with their Java products, but one thing they do wrong is in how they name their versions of Java. J2EE 1.4 is an environment that allows you to do very many things. Short for Java 1.(2) Enterprise Edition, it is a set of tools used to write large, distributed applications, although from the name, it is hard to discern that fact. Since distributed applications have many parts, simply understanding how those parts can be put together is a major undertaking. This book is designed to give the reader a broad overview of J2EE, the various components and what each is used for.
   There is very little code in the book. What does appear is skeletal and easy to understand. The premise is that Antoine is starting an online gourmet pizza business after being successful in selling locally. His online component is wildly successful and before long he realizes that he must scale his online business dramatically upward. The current structure of his website does not allow for rapid and efficient expansion, so his online business is in danger of collapsing under the weight of his success.
   The book is designed to be an overview of the different ways the components of J2EE can be used to create an application server. It is not in any way meant to be an in-depth technical manual, the goal is to explain the components of J2EE in a way that non-technical people can understand. That goal is successfully met, there is never a time where the authors rise to a technical level beyond that of someone who understands how software operates.
   If your goal is to learn the overall use of J2EE in creating large distributed systems, then this is the book for you. However, if you possess some technical knowledge, then it will probably not be interesting or challenging.



2. Good non-techie intro. I'm now ready for a technical introduction to J2EE.
   
   It helps to have an introduction to enterprise architecture (i.e. Martin Fowler Enterprise Patterns) before moving on to this book.



3. The book is full of "cutesiness" which makes the book much longer than it need be.
   Conversely - what the book lacks is a good solid explanation, with detailed examples, of basic elements of J2EE like the Home_interface Component/Local/Remote interface - and how they actually tie-in with the Clients and RDBMS. It's not that these things aren't mentioned. They are. For example chapter12, p.148 :
   "The Home interface is kind of like a hostess at a restaurant. In fancier restaurants you don't find your own table and order your food directly from the chef; you ask the hostess to find you a seat and the hostess assigns you a waiter who talks to the chef.You ask the waiter for your food".
   Followed by 8 pages containing some codes and and explanations - that don't really explain how you connect everything together.
   
   So in conclusion - if what you want is to know the buzz-words, the book is to long.
   If what you need is technical detail beyond a long explanation why J2EE is like a fancy restaurant,
   and that: "The database just sits around holding data. Sometimes it hums snatches from Broadway musicals softly to itself but mostly it doesn't do much. And that doesn't do anyone any good. like a library without a librarian" (p.159)
   - than this book is disappointing



4. This is quite possibly the worst book ever written. I've actually not finished reading it, and probably never will; I've tried three times, but end up putting it down after 20 pages every time I pick it up. I recently brought it on a plane trip with me so I had several hours with it, but it's just not possible to get very far. You truly have to suspend disbelief while reading this piece of garbage: "Are they really writing this? Doesn't Prentice Hall use editors? Or at least some sort of grammar check?"
   
   Every aspect of technology has been personified or anthropomorphized. The Dolphin is constantly talking to the Statue of Atlas who in turn talks to the Golden Retriever, but they only explain once that the Golden Retrieve equals the database server, so after five pages when you've forgotten that fact none of it makes any sense any more. You literally need Cliffs Notes to decode what the authors are talking about. All the "characters" talk to each other, with dialogue and everything. And the dialogue is AWFUL. If you can't write poetry or prose, then why bother writing a little play between the web serving Bee and the web containing Horse? Reading terrible writing is surprisingly distracting. Midway through trying to comprehend a concept the authors cut away to an example where the Scarecrow says something unbelievably stupid to the Cowardly Lion and all you can think is "how did this make it into the final draft?" Congratulations: you just wasted the last five minutes of your life, and you have nothing at all to show for it. (Aside: they actually use the characters from the Wizard of Oz to represent some concept, but the analogy is so flawed that they literally take several sentences explaining how the Tin Man represents Resource Management. You will never get those three minutes back, and you will be dumber for having read it. Shouldn't an example metaphor whose purpose is to illustrate a point be somewhat obvious?)
   
   This book is 90% filler and 100% poorly written. I just cannot figure out who the target audience is. It is not for anyone remotely technical. Anyone who is functional and has risen to a managerial role is probably too busy to deal with the ridiculousness of the book. But if you do have the time to wade through this disaster and are simple enough to appreciate this mess, then how could you possibly need to know about J2EE? Who are you people that gave this book five stars?!? What companies pay your salaries?!?



5. I continue to recommend this book to people who are unfamiliar with the Java Enterprise platform. This book is well-written and easy to digest--the perfect introductory book!