No comments about SCJP Sun Certified Programmer for Java 5 Practice Exams (Exam 310-055) (Certification Press).

4 comments about Jini Example By Example.

1. everything you need to start developing services and clients and nothing unnecessary.

   clear, concise explanations, better than those in the Professional Jini book.

   sample programs/code needs better formatting for better readablility though




2. This book looks like it was rushed into publication. The example code is formatted incorrectly in every example and much of the text is straight out of Edwards' "Core Jini" (a better book but somewhat outdated). I also don't like Edwards' informal style of writing. The text is peppered with colloquialisms and redundancy and is generally not concise. He explains the one to four page code chunks awkwardly in text before or after the code rather than provide useful comments in the code. The comments that are in the code are sometimes obvious like documenting a function "addRates" as "adds a new currency exchange rate". I hope Edwards is writing a better book for Jini 1.2. Keith, if you are, let me know and I'll help you with that pesky English.



3. The main problem I find in this book is that Edwards uses an example, and then to build upon it adding more functionality, extends it...again and again etc. You are left with a confusing hierarchy of classes.
   So, if you want to jump in, find out which classes are needed to build clients and services, and get to it, anything by this author is not worth your time.
   You are either forced to use a hierarchy like he does ( which is a bad idea ) or back track through every one of is classes to find out what functionality you want.
   The Wrox book on Jini might be the best book around.

   The only reason I even gave it 2 stars was because if you do want to learn about the lower level/ non utility classes and how they work the first few chapters are ok for this.

   Also, god forbid you have a question for the author...don't expect a response.




4. If you learn better from an example than from a dry reference, this book will be a great way to get into Jini.

   It has little by the way of background explanation or reference material, but the example code (and the instructions on installing, configuring and running the various parts of Jini) are comprehensive and detailed, building into two interesting case studies - a chat system and a distributed remote storage system demonsrating all the Jini features.

   For discussion, hints, tips and experience get "Core Jini". For a reference get "Jini in a Nutshell". For the best and most interesting examples, get this book.

4 comments about Java Testing Patterns.

1. "Java Testing Patterns" is one of those books where it appears nobody edited. Java class/method names and acronyms are used in lower/upper case interchangeably. Writing class names in all lowercase in a Java book doesn't inspire much confidence in the accuracy of the rest of the book. There are many typos and inconsistencies that make it hard to read.
   
   The formatting is also very poor. The code looks good in Eclipse, but not in the book. Lines wrap without indentation. Similarly, UML diagrams are randomly split into pages. They are supposed to be on the web, but they aren't yet.
   
   The intro states a target audience of "software engineers, engineering managers and software testers." This book is heavily reliant on reading code. After the first few chapters, I don't think managers or testers would benefit.
   
   Speaking of code, I think the code is too verbose and complicated - especially for a book. A few times, a simple JavaBean's source takes up one to two pages. One DAO takes up 12 pages. There is a test method with 16 branches. These examples make understanding quite difficult.
   
   Now as for what the book does well. There are five good chapters on patterns. However, two are in essence the Factory and State patterns. The appendices are very good too. I wouldn't buying a book for three chapters and some appendices. Other books cover the material better. I would not recommend this book in its current edition.



2. I've only read a couple patterns books, including the classic GoF. The only thing I don't like about the GoF book is that the explanations are very academic and the examples are far from useful in my work.
   
   What I like about this Java testing patterns book is that it is extremely practical and therefor useful. For me it bridged the gap from a highly theoretical treatment of patterns to a detailed understanding of how to really employ patterns while coding in Java. The examples are rich and detailed and reflect the kind of development work I do (ie the examples are not simple strawmen set up to demonstrate an isolated concept).
   
   Also, this book does a very good job of presenting a selection of patterns that you are likely to use *in combination* and with popular development tools. For instance the book not only describes the Mock Object, MockDAO, and Test Database patterns but also explains best practices for using DbUnit, JUnit, and other tools when testing code written with these patterns. I'm extremely thankful for that advice which is the kind of thing I've not found anywhere else.
   
   The code actually works (amazing!) and is very useful. The formatting is at times a little odd in the book but it is defintitely readable.
   
   I also appreciate the size of the UML diagrams and their readability...thank you for not squeezing them all on one page!
   
   The only downside to this book is that I wish it covered more patterns. Hopefully the authors will cover more in the next edition or release more material on the Web site.



3. "Java Testing Patterns" is a welcome take on maximizing the use of patterns in your Java development and testing process. The book begins with a very crisply written description of what testing is and what it is not. There are some absolutely vital concepts in this chapter that anyone responsible for testing code should read and understand.
   
   The next chapters each describe the concepts involved in a particular type of testing: unit, integration, end-to-end, and database. These chapters do an excellent job of isolating discussing the purpose, process, and pitfalls involved in each type of testing.
   
   From there the book dives into the actual patterns. These chapters are full of good testing advice, and they contain code and sample applications that demonstrate a realistic employment of each pattern. My only nit with this book is that a couple chapters are not quite as well written as others (I thought Self-Shunt would have benefitted from additional description and analysis).
   
   The book also does an excellent job of placing patterns within the entire development/testing context; it describes not only the patterns, but also the tools and processes you need to use with these patterns to fully test your application.
   
   This is not your usual patterns book, which makes it a welcome addition to the literature.



4. If you are a patterns buff you will probably love this book. It takes a Gang of Four Design Patterns approach to various types of testing, starting with unit testing in the abstract, but then covering use of mock objects, test database, exception testing and other areas. It's a wide coverage area but the patterns remain fairly abstract. For those of a more pragmatic mind you should look at Manning's JUnit Recipes.

5 comments about Java Programming with Oracle SQLJ.

1. I found this book to be concise, to the point, and very readable. A large amount of material was well presented in a relatively small amount of space. And the examples worked as advertised.

   I found myself incorporating the material presented into my work before I finished reading the book.

   An excellent resource.




2. This is a great book if you are interested in building J2EE applications and want to link to an Oracle database but don't want to learn the complicated JDBC API. It isn't an 'intro to programming' book like so many out there; it is, however, perfect for object-oriented programmers who are wanting to learn java with a quikness. Finally, a great SQLJ book has emerged!



3. This is an outstanding book. SQLJ is a simpler way of embedding SQL statements in a Java programming, and is possibly the successor to PL/SQL.

   I liked this book because it covers SQLJ programming, as well as:
   1. Oracle SQL.
   2. Oracle PL/SQL.
   3. Oracle JDeveloper.
   4. Developing J2EE components for the Oracle9i Application server (9iAS) such as EJB, servlets and JSP.
   5. Java stored procedures.

   I liked the author's writing style: it is clear and to the point. I found it very easy to read, and was able to follow the examples in the book and apply them to my own programs.

   I highly recommend this great little book!




4. This is just an easy read with good code examples. It is geared toward the intermediate or beginner programmer, and presents clear explanation for easy understanding.



5. My knowledge of Oracle and Java is beginner/intermediate level and I like this book a lot.

   The book explains how SQLJ relates to SQL, PL/SQL, Java, JDBC and it provides a good introduction to the JDeveloper IDE (Integrated Development Environment).

   The book is written very clearly and the appearance and organization of the text is well up to the O'Reilly standard.
   I can't comment on the worked examples yet as I have not yet tried them out.

5 comments about Enterprise JavaBeans Component Architecture: Designing and Coding Enterprise Applications (Java 2 Platform, Enterprise Edition Series).

1. It is not just an EJB book. It shows how to integrate JSPs with EJBs by using various EJB patterns through examples. The patterns include Session Facade, Value List Iterator, Data Access Object, etc. It also covers enough information about EJBs itself. The book differs from other EJB books in the market. Other books only focuses on EJBs itself, but this one talks about JSPs, EJBs, design patterns - it's kind of all in one. The only drawback of this book is sometimes it's very hard to follow. You cannot read it for too long, the flow is missing. May be it's just because the EJB architecture itself is too complex. Although, Ed Roman's Mastering Enterprise JavaBeans book makes learning EJB peace of cake. I wish this book was also written such a way.

   There are verious reasons why I bought this book:

   - It shows how to integrate your EJBs with JSPs.
   - EJB design patterns are exposed.
   - Fairly good examples.
   - Good end of the chapter summary.
   - Concise and well designed chapters.

   The bottom line: It's a good book worths the price. If you don't have any EJB book, you can start with this one.




2. Technically, it's really a great book. Well written and very
   informative. The description on the back cover, of the book,
   summarizes it better than I could, so I will not repeat it
   here � see above �Editorial Reviews�. In addition, this book
   is one of the very few technical books that contains example
   code with it all working, not just some of it. The code is
   available by downloading it from the authors Web Site.



3. There is no other way to say this. This book is by far the best book on EJB 2.0 that I've read. There are also EJB 1.1 references, but they didn't mean much to me because I started with 2.0

   I challenge anyone to even find a typo in this book. There has to be some I am sure, but try and find them. I do not agree with another review about the major flaw with this book. If you don't know how to create .war or .ear files you shouldn't be reading this book! Just my opinion.

   I hope these 2 write another book on any Java technology soon! I will be the first in line to buy it!!




4. This is an excellent book to learn EJB. I started to study EJB by trying out couple books in the market. But failed to understand and further frightened with J2EE. Once i started to read the book, i have a better understanding of what is EJB and J2EE. Buy the book, go through the contents, download the source codes, deploy to a J2EE compliant server and enjoy learning. It is really a nice book worth investing.



5. It is an introductionary level book. The only good thing is it provides an integrated example through out the book, and adds more features and components with introduction of Stateless, Stateful, Entity, Message Driven bean in each chapter.

2 comments about Java for Bioinformatics and Biomedical Applications.

1. Finally, a book that introduces bioinformatics using Java. While Perl is great for pattern matching and basic scripting, it is not at all an ideal choice for complex bioinformatics applications at all levels of complexity. Books like this one help train a new generation of bioinformatics experts with a broad-based training in computing (not just Perl scripting).



2. This book is more about how to write Java applications that connect to existing systems (such as BLAST) that Bioinformatics and Biomedical professionals already use, rather than how to write Java versions of those systems, the algorithms used in those systems, or algorithms generally relevant to the mentioned fields. While teaching someone to write Java applications that could send data, request service, and parse then display the results received from the queried systems is useful, such a book probably does not warrant such a high price tag as a book that teaches one how to write Java versions of algorithms useful for the Bioinformatics and Biomedical fields.

5 comments about Developing Java Beans.

1. Actually I bought this book about two years ago, and at that time Java Beans were gaining popularity as an instance of component model for distributed computing. I was at that time interested in Enterprise Java Beans rather than client side beans. So I did not really use the book that much. However, from the limited reading I did, it seemed like a very well written book for the uninitiated, gave a good view of the Beans, how to create the client side beans etc. However, since then I have moved my field of interest from Java to some thing else, and in the mean time EJB have taken an increasingly important role in the server side component model. So I hope this book is updated or the same authors write a separate book on EJB (more meaningful to do the latter).



2. This book is titled "Developing Java Beans". It spends lots of time to talk about the detailed architecture of Event model and other important topics used in Beans. It is well written and easy to follow. However, may not be the good book for those poeple in a rush just want to how to write a Java Beans.



3. This is not a good tutorial about Java Beans. In order to explain the Java Bean concept you have to start with the Java Beans specifications of Sun. This would answer question about which things are relevant and why they are relevant in JavaBeans development. Now the the reader almost jumps into a long winded explanation about events and adapters, wondering why this is relevant and what the writer wants to explain. To make matters worse: the example contains errors! Basically, after the first three chapters I was utterly confused.

   This book also needs a clearer description about the use of Java Beans. In a next update we definitely need a chapter about how JavaBeans are used in Java Server Pages.




4. I've been programming for 10 years, and I have 2 bookcases full of ORA and ADW books. I have to say that this is among the most confusing programming books I've seen.

   I'm in the same position as the guy below who's confused after 3 chapters. The first couple of chapters of this book seem to be a tutorial about event handling, and applet creation. Applets? I have no idea where the author is going with this stuff. It's not that I don't understand the concept of event handling, it's just that this guy does not explain what the heck handlers and listeners have to do with beans. I'm sure they do, somehow...

   Perhaps if the author provided an an explanation up front about where he's going with the code, I'd stick with the program. Even better, how about an overview of why beans are so great and useful, with some trivial examples. Then progress to the 'real world' stuff.

   I'm dissapointed with this book because I need to learn about Beans... fast. 3 chapters of working bean code and good examples would have been enough for my instincts to kick in and take me the rest of the way. I don't have the time to search for answers, I thought that a $30.00 investment in an ORA book would have saved me hours of searching. Well, not this time.

   If you can get the applets from chapters 1 and/or 2 working, please post how in this forum. You'd be doing a lot of folks a favor. Good luck figuring out if you should be compiling *.java.1 or *.java.2 examples.

   That's enough about this one... Now I have to find a GOOD beans book.




5. A nice little text with useful snippets of code, and advice on
   applying them. However, the order of presentation can be a little
   confusing. Also, some of the topics were a little beyond what I
   needed it for, though that is not a bad thing.
   
   What I found annoying at times was that it did not always address a
   question I may have had about how to apply a particular class.
   Having "Learning Java: 2nd Edition" helped somewhat to alleviate
   this as it had more in the way of explanations than this book.
   
   For the absolute beginner I would probably recommend another book.
   However, if the reader has background knowledge in Java, or other
   programming languages then this book will probably prove to be
   useful.

No comments about Introduction to Cryptography with Java Applets.

No comments about A Guide to Programming in Java.

5 comments about Aspect-Oriented Programming with AspectJ.

1. As the subject is relatively "new" for the general public, the documents obtainable from [URL] had been the best tutorial until the arrival of this book.

   The author has a in-depth understanding on the AspectJ and he was able to present his knowledge clearly in his book. The "aspect traces" provided were able to help the readers understand how AspectJ really works. The examples helped me to grasp the difference between the "call" and "execution" pointcuts.

   I didn't give this book five-star because the few chapters on the "AspectNews" application were not convincing because I don't think it likely that AspectJ will be applicable to a non-trivial Web application for the exact reasons given by the author in the last chapter (ch. 14) of the book.




2. I have never rated a book as lowly as I have for this one. It is horrible. Let me count the ways:

   1. They forgot to edit the book

   Not only are there spelling errors and grammatical errors, but numerous code errors, API errors (or ommissions), and code left out of the book! The grammatical errors actually make certain parts of the book impossible to understand. I had to search on the web to find the answers.

   2. VERY poor organization

   In one chapter he tells you the code you'll need to compile something we won't do until four chapters later. Worse, although he attempts to create an incremental build of your code, the code you can download online only works in the final version. Of course if the book actually had the incremental code that wouldn't matter, but it only has some of it. I spent half my time just trying to figure out what in chapter 4 goes with what in chapters 2, 5 and 7 (for example).

   3. Missing SQL Code

   I had to guess what the tables were like since he forgot to include SQL code in the book AND (!!!) it isn't in the code download online either!

   4. Poor explanation of everything

   Almost every example he gives in the book has either no explanation, or a useless one. For example, he might tell you that some code "introduces" the class to their new parents and that "introduce" is the official name for this action. Of course, don't ask him to define the keyword "introduce" for you. You have to figure that out for yourself. This whole book reads as though it were written by someone who loves to be smart, loves big names and acronyms that define him as a high level programmer and doesn't want to sound too simple by actually taking the time to explain it to you. As they say, "those who can't do, teach." In other words, those who weren't naturals at it had to struggle to learn so they understand they have to explain it to you - Kiselev does not.

   Don't buy this book.




3. I liked that book - it manages to squeeze a lot of new information into relatively small volume - though may be at the expense of the ease of understanding by novices.
   Explanations are concise and relying on reader's intelligence, without "I'm teaching you" condescending approach so common for many "methodology" books.

   Code examples are useful - if you don't care much to compile them. They rather have to be treated as pseudo-code that illustrates the AOP concepts - and very effectively, I think.

   I wish more books like this one were published - short, to the point, respecting both my time and my bookshelf space.




4. If you need a book that explains the technology, then buy this book.
   If you need a reference guide, then buy this book.
   If you need some examples that illustrate the power and limitations of this technology, then you should *definitely* buy this book.
   If you are looking for the big picture, concerning the big freaking aspect-oriented programming thing, if you want to read about scientific justification, and if you're looking for proof, then you *might* consider buying this book, but I didn't find it very valuable from that perspective.
   If you just want to be entertained, then you might consider buying something else. Maybe something like 'The Amazing Adventures of Kavalier & Clay'.



5. I have read this book with great interest. My conclusion - this is
   excellent introduction into new field of information technology. The great
   advantage of the book is the "from simple to complicated" style of
   presentation that allows to recommend it as a great introductory course for
   self study. The extension of Java classes into AspectJ can play the same
   revolutionary role for Java developers as some years ago
   Microsoft MFC implementation did for Windows 3.1
   programmers. The concept of dynamic crosscutting can be enormously useful
   for everybody involved in the development of real-life business applications.
   The style of presentation allows to start using AspectJ for application
   development very quickly. The large number of simple examples is
   represented in the way similar to the famous Stroustroup's C++ book.
   This book can be recommended to everyone who is interested in the new way
   of thinking and the current state of information technology innovations.

   I have not succeeded to compile and execute the code from the book due to a
   lot of technical problems. The code listings and examples in Kiselev's book
   can be recommended as invitation to think and develop you first application
   in AspectJ.