4 comments about Eclipse Kick Start.

1. The latest Eclipse is well described here by Valcarcel. It has rapidly become perhaps the most popular IDE for Java programmers. Of course, being free didn't hurt the uptake.
   
   He assumes you have already programmed in Java itself. The book has three parts and an Appendix. The first part covers the basics. Essentially, it shows how to write and debug a standalone Java application in Eclipse. Competently done. But frankly, little to distinguish from other Eclipse texts. At this level, we are basically in an IDE equivalent to IBM's earlier Visual Age for Java, circa 2000. From which Eclipse is derived, by the way.
   
   The second and third parts of the book are far more interesting. Part two is all about using plug-ins to build up an application. Here is where Eclipse really shows its power. Also, the author describes how to make a Web Service using Eclipse. Web Services are a hot topic, and for those of you wanting to get into it, without giving up your familiar Eclipse environment, that chapter may justify the entire book.
   
   Finally, part 3 is about the basics of writing a plug-in. You can really dig deep into the Eclipse framework for this. It may be the most advanced part of the book.



2. I needed a book to get up to speed on Eclipse 3.0 for work, I found it with Carlos Valcarcel's book. The chapters are just the right length and cover a vast array of topics, from MyEclipse, GUI Layout, CVS, Struts, building your own plug-ins, its all there and then some. The book's site can be found here: http://www.eclipsekickstart.com/



3. The value in this book is it's breadth of coverage. It never digs very deep into topics. The coverage of UML editing, for example, is about 30 pages. But that's thirty more pages than most of the Eclipse books have on UML. And the coverage is of a wide variety of these topics, including Struts, web services, JSPs, and others. The basics are covered as well, starting with installation and the basics of starting up a project, going through source control, unit testing, and refactoring. It's all there. It's just set to a whirlwind pace that may leave you a little breathless. Good book, just not for very beginners.



4. I found this book a pretty good intro for a Java Developer/Architect who knew Borland JBuilder and Ant very well but who "just didn't get it" in terms of Views / Perspectives in Eclipse etc.
   This book was a good tutorial / introduction to the various features in Eclipse and how to us it (focuses on the 20% of those features you will use 80% of the time). I found Eclipse 3.1.2 was a bit different than the version he used and with Eclipse 3.2 now out (Q2 2006) I'm sure a few more changes have occurred but the exposition style is good and gets to the point.
   Although I think it is the best book for the purpose, I think those who want to learn and use the Eclipse Java IDE don't have much in the way of quality choices to learn it in terms of books at least.

4 comments about Pro Eclipse JST: Plug-ins for J2EE Development.

1. It seems that everyone is looking at Eclipse for their next development project.
   
   Having developed J2EE applications using JDeveloper, JBuilder and WSAD - I was looking to learn yet another IDE. Yet Eclipse poses some unique challenges. Its open source and worse still, for J2EE, one needs to use a collection of open source products.
   
   Pro Eclipse JST was just what I needed. It's a concise, information packed read written for the experienced developer. The text stepped me through the setup in an intuitive manner with plenty of screen shots and helpful graphics.
   
   Highly recommended.



2. Hello Chris and Hakeem,
   Please update your driver for the upcoming release of the WTP, it is outdated and is not usable with the WTP 1.0 Release Candidate (any version) . Also please provide support for at least JBoss 4.0.2 since it is the Application Server that you have chosen to use in your book. Other than that, keep up the good work.



3. The authors address both J2EE 1.4 and the Eclipse toolkits and plugins, focusing on the capabilities the IDE provides J2EE developers. Chapters introduce the Web Tools Platform, Java Standard Tools, Web Standard Tools, etc and cover the spectrum of tasks for components such as servlets and EJBs and everything in between. A very useful book, excellent for novice and intermediate developer.



4. Before I knew about JST, I painstakingly developed J2EE applications and components as traditional Java projects in Eclipse. The JST provides quick development solutions to get your EJBs, Servlets, Web Services, etc developed quickly and deployed to the application server of your choice. I thought the book did a great job of walking through the wizards for creating the different types of J2EE projects.
   
   If you are looking for a book to provide in depth discussions on what EJBs, Servlets, Web Services, Entity Beans, JSPs, etc. are, then this is not for you. But if you already have a J2EE background and would like use the Eclipse IDE to develop your components, then I would recommend this book. My only complaint about the book is that it did not provide any discussion on how to version control your components. For example, if you create a WAR File for a web application that you want to package inside an EAR file, do you version control both the WAR and the EAR as separate projects? It seems that projects under version control would get messy if you have to version control every EJB and Web Application as a separate project.

3 comments about Groovy Programming: An Introduction for Java Developers.

1. Short, plain, concise presentation of all features of Groovy, much in K&R style, without too many words and too much philosophy. I have both books, i.e. this one and "Groovy in Action". "Groovy in Action" concentrates on design goals and philosophy, and is more about using the language than about language itself. Reading "Groovy in Action" is fun, but when I do programming I have "Groovy Programming" on my desk all the time. And use it quite frequently.
   
   By the way, the previous review here misses the point. Reviewer reviews Groovy, but not the book. Pity that he doesn't unserstand what are scripting languages and how they are used.



2. As I write this review there appear to be two books on Groovy: this book ("Groovy Programming") and "Groovy in Action". I would recommend you read both books, but tackle "Groovy Programming" first.
   
   "Groovy in Action" was recommended at a conference I attended, so I started with that book. Although it has wonderful writing and explained the "why" of Groovy quite eloquently, I found it hard to quickly get into the Groovy language as I read that book. Details of APIs and language features were scattered about in the text, so you can't easily jump in and quickly learn about a topic. You have to read it straight through - and it is quite verbose.
   
   Programming Groovy is, on the other hand, a straight-forward exposition of the language itself. You actually *can* read it straight through and make rapid headway since it is so concise. So to get going quickly, try "Groovy Programming."



3. Some of the material is a little dated but overall this is an excellent primer on Groovy.

4 comments about Oracle XSQL.

1. The author has done a excellent job. It describes about the important pieces in a dedicated chapter - XSQL architecture. After that he delves into SQL, PLSQL, XSQL , XSLT. The best part is chapter 14 on Building XSQL web applications. This explains how all the above pieces are put into a working model. The material is written keeping oracle 9i in mind. As a whole, I felt very comfortable reading the whole book.

   Especially for database developers who come from sql, plsql background and are trying to get into web development world ( without the hassle of learning Java Servlets, Jsp etc ... ), I would definitely recommend it.




2. This book describes a new and interesting approach to some well-known web development problems. Though not all of the technologies described are mature (yet), they are largely standards-based and likely to grow in popularity in the coming years. The author does a good job of showing how several different technologies (SQL, XML, XSLT, HTML and others) can be focused into a coherent whole. Probably not for beginners, but anyone with web development experience should be able to learn a lot from this book.



3. Mike has done an outstanding job with a complicated topic, a remarkable achievment from a Carolina fellow!



4. There are few books out that deal with Oracle Text and XSQL. Applying the methodologies, practices, etc. I found no need to search for another reference.

5 comments about Mastering JXTA: Building Java Peer-to-Peer Applications.

1. One of the most striking things about this book is the inclusion of real-world examples. Those who have used the distributed.net application will like the chapter that uses JXTA to build a framework for distributing computations.

   The chapter on building a three-tier encrypted storage system shows the power of the JXTA specification and JAVA implementation.

   I highly recommend this book for learning JXTA. The writing is clear and the numerous examples will have you coding peer-to-peer applications in short order.




2. Probably the best book I've read on how to build a p2p application. Covers all of the basics, with a very clear introduction to JXTA and related technologies. But the best parts for me were the tutorials showing how to build real-word apps from beginning to end. The detailed code examples really helped me in developing my own p2p project. Definitely worth the price of admission.



3. I bought the book yesterday and started off with the first chapter. The next thing I remember is that I am done with the book and I feel some degree of mastery over the subject. The author deserves a standing ovation. Dont forget to have JXTA platform API documentation and code examples to go along with your reading



4. JXTA has grown since the book was published. Much of the book's details are still generally valid. But JXTA is still a very gritty, low level framework. Chances are that if you want to learn JXTA, you will be downloading the latest, or at least a recent, release from jxta.org.
   
   Well, the thing is, it is very much a hands-on programming thing. For hardcore developers. You probably will need a text as close to the release you're using as possible. Avoid this book.



5. This book is not so rare novadays examples of how a book could be even less comprehensive than a API specification. Author constantly gives unclear definitions to a variety of terms, explains unknown through unknown and does all other sorts on bad things that make reading of this book harmful for anyone but an experienced JXTA user brushing up on something. The plan of the book basically copies documents published on jxta web.
   If you want to get a clear picture of what JXTA is and what it could do for you, get something else.

5 comments about J2EE Design Patterns.

1. Old wine in a new bottle. Put simply there's nothing new in this book.

   If you are just beginning to wade through the vast land of J2EE, you will find lots of introductory material to help you get started. The preface pronounces the audience as Java-aware readers who may not be fluent with J2EE technology stack. Beginners will appreciate the slow pace, logically ordered chapters, thoroughly descriptive background information on every pattern presented and an entire chapter dedicated to UML. However, if you are familiar with the core J2EE patterns published by Sun, there aren't a lot of things in this book that will interest you. Some things worth mentioning are - strategies for content caching, Serizized entity strategy for rapid development, and use of soft references for being thrifty on memory usage. The chapter on Enterprise Messaging Patterns is particularly interesting since it is an area that has attracted some interest lately.

   Why another book on patterns? The bookshelves are already packed with several noteworthy titles on this subject and it is only natural to expect to see something new in new titles. This book is a far cry from "CoreJ2EE Patterns" or even the "Java Enterprise Best Practices" from the same publisher.

   They could have done a better job by cutting down on teaching the basics and including all of Core J2ee patterns. ACID transaction pattern isn't a pattern at all, but just a fundamental concept. The selection of best practices covered seems arbitrary at best.

   - Ajith Kallambella




2. There is nothing remarkable about this book. It loses momentum about halfway through. It isn't a big book and there doesn't seem to be much depth in the coverage. Look else where.



3. There are a large number of Design Patterns books available in the industry over the last decade. Crawford and Kaplan's J2EE Design Patterns offers a fresh look at the subject in both a practical and readable manner. Instead of just another catalog of design patterns, it provides insight into the real world scenarios of where these patterns can be employed. From a J2EE designer perspective, this book is a great addition to the study desk.



4. It's good for me because I'm still a beginner of J2EE, its focus on using servlet, jsp and JavaBeanIt's good for me because I'm still a beginner of J2EE, it focuses the patterns on using Servlet, JSP and EJB, it told that how to determine and improve scalability and extensibility, and how to model and implement the system. It is used UML diagram for represent the pattern; some of example covers few chapters to let the content easy to study, some of code is very common for let reader reuse in different application.
   
   -calendarw



5. This book could be an introductory book on understanding J2EE design and guiding principles but beyond that you don't find much help. The book has poor editing and repetitive style of explaining concepts which annoys experienced J2EE developers. If you are looking for J2EE patterns to support real-world implementation with exhaustive details then you must consider reading Core J2EE Patterns (Alur), Core Security Patterns (Steel) and Enterprise Integration Patterns (Houpe).

5 comments about Up to Speed with Swing.

1. this is one fo the really good books on Swing. Nevermind ath it's slightly out of date..the writing here is very very high quality nad you'll come away with a great foundation. His "useful groupsings" of methods together into meaningful categories is so much better than the API dumps a lot of other books are...



2. I have done quiet a bit of research on the net before I ordered this book, just so I get the best one. It looked just the book for me to start learning Swing. (I know Java already). When I looked through the book I was shocked to see that it was little more than a doorstop. Gutz is one of those few gifted individuals who really knows what he's talking about. BUT doesn't know how to explain it clearly. Apart from his coding style and the last two chapters this book rushes through every aspect of swing with very little to say about all parts of Swing. If you are looking for a book that will REALLY help you learn Swing, I recommend you take your hard earned cash elsewhere. I am returning it. And make a decision probably between the Sun's tutorial and Matthew Robinson's Swing book.



3. I read all the reviews and thought this book would provide a good reference on Swing. While it does introduce developers to Swing, I've subsequently found that it glosses over or fails to cover topics that are important once you start developing with Swing.

   For example, the book barely touches on layout managers. But an understanding of layout managers is essential to development of a good UI via Swing. The book also has no/minimal coverage of areas such as text selection and carets. I suspect that there are other areas not mentioned but I haven't proceeded far enough with Swing to recognize what else is missing.

   With hindsight, I wish that I'd bought the Java Swing book published by O'Reilly.




4. Upto speed with Swing by Steven Gutz is really a fast track to most advanced GUI , the SWING. The author covered all features of the SWING. The book is very interesting to read and complete with working examples. All the chapters are organized and well written. It defenitely a needed book to learn things fast and work with, rather than voluminous and time consuiming books. I recommend this book for beginner/ intermediate level of java programmers. Thanks for Steven Gutz for his efforts to put the java programmers on fast track!!!



5. My copy has a little different cover, says "2nd edition", and is copyright 2000, but I couldn't find an exact match on Amazon.

   The book is a good introduction to Swing, getting this Java programmer started fairly quickly. One thing that's appreciated for this server side Java programmer with no previous familiarity with AWT is the brief section reviewing AWT - which you unfortunately also have to know to use Swing, it seems.

   That said, you run into the limits of the book rather quickly. There's a lot of detail on how to use each component, but very little on how to use it well. Coverage of layouts and events, both critical to building a good UI, is sketchy.

   Also, there's no real reference section. Even just a brief listing of all the relevant classes and their methods would be really nice - say, similar to the reference section of David Flanagan's classic "Java in a Nutshell".

   Finally, the author seems to be somewhat Windows centric, which is a little unfortunate since the main reason to use Swing is to produce a cross platform product.

3 comments about Concurrent and Distributed Computing in Java.

1. I bought this book because I was interested in implementing
   distributed algorithms. It has a good overview of the fundamental
   algorithms and I found it helpful to see actual code. It's the only
   book I know of that actually provides implementations rather than
   pseudo code.

   On the other hand, the algorithm descriptions were often condensed, and I
   expected a more formal approach. I often found myself reading eagerly
   to learn about an interesting variant of an algorithm only to find a
   reference to a journal paper. It would be useful to cover a few more
   variants more deeply.

   Also, I was hoping to get an idea of an algorithm's usefulness and
   performance in practice. Or is a particular algorithm more of
   theoretical interest? The answer was not clear to me, although in
   fairness, this was not the author's main purpose.




2. I got this book because I have been a fan of Garg's Elements of Distributed Computing ever since I first read it. Concurrent and Distributed Computing in Java seems to be really great buy. It has a very strong theoretical foundation, but the emphasis seems to be on writing distributed programs and getting them to work. If you are a theory lover I wouldnt recommend ths book, but if you like implementing stuff then you will definitely like this book. The range of topics covered is quite comprehensive given the size of the book.



3. I bought this book a couple of years ago now. Although it has some interesting discussion of distributed algorithms its big let-down is the abysmal Java code that it contains. I cannot believe for one moment that any of this compiles, let alone works - it all generally looks like pseduo-code written for the purposes of illustration rather being of any practical value.
   
   Likewise I didn't find the material particularly helpfully structured or consistent in its level of detail. I would have liked to see more quantitive analysis of the suitability of different algorithms in practical applications and broader coverage of well-known distributed algorithms (for instance paxos and virtual synchrony are conspicuous in their absence).

5 comments about J2EE Platform Web Services (Java 2 Platform, Enterprise Edition Series).

1. When I obtained this book, I would looking for some in the trenches guidence on how to code web services using Apache Axis. The table of contents suggested that this might be an appropriate book for my needs.
   
   I should have read the Amazon reviews first. This is not a programmers guide, but a guide for architects and managers.
   
   This was a huge disappointment for me.



2. Have a look at the code snippet on pages 138-139. It's terrible. I've let go of a couple of coders over the years on the basis of their poor coding practices, and this reminds me of their stuff. Yeah, I know... the thrust of the book is big-picture high-level architecture, so nit-picking on coding style may be missing the point, but in the design and architecture area as well, I'm seeing impressive-looking diagrams and hifalutin claims of superior insights that, on closer examination, reveal a disorganized and indiscrimate jumble. Right now, I'm inclined to return the book. This book might impress your managers, but it shouldn't impress you.



3. I have bought 50+ java books and this is probably the only one that will survive the bookshelf. This book is to J2EE/Webservices what Kernigan and Ritchie is to C and Bjorn Stoustroup is to C++.
   
   Unlike the other java book Ray Lai blends the Enterprise Architect point of view with the technology. This is especially important in an organization such as the one I work for where java and webservices are new. I've cited Mr. Lai's section "Establishing a Business Case" and and the chapter "Web Services Architecture and Best Practices" in peer reviews and the subsequent white paper which I've written.
   
   There's also something in the book for the code warriors. An unexpected gem from trying the coding examples was the discovery of sun/server included with the java webservices developers kit (JWSDP). This java server from Sun is the most lightweight and administrator friendly java server that is freely available. If you're simply wrapping a java class with webservices, you're repeating this on multiple computers/platforms and you are inside the firewall this is the perfect technology choice. Unlike other application servers like jboss, weblogic and websphere, it is lightweight (doesn't hog cpu bandwidth and memory) and administrator friendly (works with other apps and quick/easy to install).



4. I agree with the previous reviewer of the book - This is a classic. If I go by other reviewers' comments, I may probably buy not buy this book but I read the book at a local bookstore for almost an hour. From the writing, one can tell that the book is written from an experience author with hands on experience in web services.
   
   This book has a lot of practical insights and not about theory of web services. It also covers areas such as how to integrate with legacy applications. This book is definitely written by experienced author. This is not just a book for ordinary Java programmer but a Solution Architect.



5. If you are Java developer, don't get carried away by this book title. This book has no conceptual relevance to j2ee or jwsdp. The book is also poorly written and the code examples are completely not usable at anyform. I did a big mistake picking this title.

5 comments about J2EE Developer's Handbook (Developer's Library).

1. This book fails to actually teach anything. The author goes into long drawn out paragraphs and fails to say much. If you don't know J2EE, stay away from this book! If you are not great at J2EE and want to get better, don't buy this book! Only buy this if you want a refrence book, but it's not even good for that, IMO.



2. This is my reference book that I liked most for J2EE. It describes all of the J2EE parts in alot of detail. It is different by having UML diagrams that describe each J2EE part then the author describes the J2EE part that the diagram shows. This makes it easy to understand that J2EE part. Also has code examples to run and in the book. Every J2EE part is covered like EJb, sevlets, Web services, JAXR, JMS, and on. They are able to cover this because the book is biggest one I have with almost 1500 pages. It is organized too. Parts are described in all in good sequence.



3. This book covers a large number of j2ee apis in a coherent manner. It is a good reference book for every day use.
   Some parts of the book out dated with respected to technologies progress from it's publishing. The real life examples with oracle, weblogic, j2ee RI server is great help.



4. The book is excellent for J2EE fundamentals and hands-on learning. It goes beyond just the basics and gives details about every thing you need to know about the J2EE specifications.
   
   My only concern is whom you buy it from.
   
   Please do NOT buy it from goodtimemobilebookfair and other rogue sellers who claim to be big shots in the e-market. After I received my book for mr. goodtimemobilebookfair, i noticed it did not have appendices as mentioned in the table of contents. The pages were blank, about 20 of them and I was never informed of the abnormality ever.
   
   So you see my point, the book is good but some lame sellers just want to rid you of your money and not provide the service this online marketplace holds them under oath to provide.



5. It worth as an overview of J2EE. But people who want to first step the product should try other stuff. The book is poor about examples and verbosy about business.