Review - Oracle JDeveloper 10g

Oracle JDeveloper 10g: Empowering J2EE Development
by Harshad Oak

Sometimes you just get lucky. You write a book about a fairly obscure and expensive Java IDE and then, without any warning, the company that makes the IDE releases it to the general public for free. The book is mostly a summary of the features of JDeveloper and doesn't go in deep into any area. If you are interested in a book to get you started with JDeveloper then this might fill your need. If you are looking for a book to show you the power of JDeveloper and help you get deep into its capabilities then this isn't the book for you.

The book has some major shortcomings; first and foremost that it was written using the preview version of 10g. Because of this there are some screen differences and the flow isn't always exactly as described. It would have been better if the author had waited until the final release version. Also, because JDeveloper was formerly a purchased product, there is quite a bit of information available free from the Oracle web site. You can find tutorials, demos, product tours, etc on the Oracle Technology Network (OTN). Finally, the book doesn't cover writing your own custom extensions and instead points the reader to OTN.

So what does the book offer? It is a fairly basic overview of the features available in JDeveloper. The author looks at servlet/jsp development, UML, web services, EJB, database interaction, Swing, and a few other features including the Application Development Framework (ADF). It covers everything at a fairly high level so at the end of the book you might not know how to do a lot in JDeveloper but you will know what JDeveloper is capable of doing. There really isn't a better JDeveloper book on the market however. A book about JDeveloper with the detail available in the many Eclipse books is still waiting to be published.

This earned 2 stars on Amazon. The book is published by Apress.

This review and all my other reviews can be seen on My Amazon Reviews page.

Review - JavaServer Faces in Action

JavaServer Faces in Action
by Kito Mann

JavaServer Faces (JSF) is one of the newest technologies in the Java toolbox and is designed to make developing web applications as easy in Java as it is in .Net. JSF is designed mainly to be used inside of an IDE by dropping JSF components onto a screen from a palette. This book is an introduction to JSF and although it is far from perfect, it is still a worthwhile read.

The book starts with an introduction to JSF with a good overview of the component technology and how it works as well as a brief discussion of some of the IDEs that support JSF. The next few chapters discuss the components in depth and the book bogs down. There is too much detail with very little in the way of code samples. To some extent this might make sense since the components are meant to be dropped from a palette, but at the same time it makes it very difficult to follow along without some understanding of how the components would be used in an application. Starting with chapter 8, the author tries to put it all together with a sample application. Unfortunately, it is presented as a development case study instead of a JSF case study. We get three chapters of screens with no code behind it that includes prototype versions and final versions. This seemed very unnecessary and helped to inflate the page count. It isn't until chapters 12 and 13 that we finally get to see some detail code but by then I had forgotten what the screens introduced four chapters earlier were supposed to be doing. The book ends with a chapter on Struts integration and a chapter on developing your own custom components.

There are bonus chapters available on the Manning web site, but since some of the bonus chapters are important to understanding the material in the book, unless you are reading the book while sitting at your computer, this isn't very helpful. The book would have been much better with some serious editing and rearranging of topics. The sample application should have been simplified and combined with the component reference material presented earlier. Code and screens should have been discussed together. The bonus chapters should have been incorporated into the printed version of the book.

I don’t want you to get the impression that this is a poorly written or useless book. In fact, there is a lot of good material here and after reading this book you will have a thorough understanding of JSF. The author gives very clear (if not concise) explanations but the book is too long and parts are difficult to wade through.

This earned 3 stars on Amazon. The book is published by Manning.

This review and all my other reviews can be seen on My Amazon Reviews page.

Review - Head First Design Patterns

Head First Design Patterns
by Elisabeth Freeman, Eric Freeman, Bert Bates, Kathy Sierra

Disclaimer: I served as a technical reviewer for several chapters of this book.

Understanding design patterns and how they are used in developing an application is a critical skill. It is important that developers be able to make use of the same lexicon when discussing application architecture. Books like "Design Patterns" by Eric Gamma, et al (affectionately referred to as the gang of Four, or GoF) do well to catalog design patterns and provide this lexicon but they are difficult to use as a guide to learning and understanding design patterns, especially for the less-experience developer. "Head First Design Patterns" provides the skills required to learn and understand what design patterns are and how to use them and does it in a fun, easy-to-read way.

Although this book does present many of the patterns found in the GoF book, it is not a design pattern catalog. Its real goal is to help the reader look at their applications in new ways to discover how design patterns can simplify their development efforts. Patterns are covered in great deal, some may say in almost too much detail, but the end result is a thorough understanding of the patterns under discussion as well as the whole reasoning behind using patterns in the first place.

Each pattern is discussed in a similar way. It generally starts with a programming problem that has been handed to the development team. They look at a typical, non-design pattern solution and point out the problems with this solution, usually involving issues with making future changes. The team then starts looking for alternate solutions and discovers a design pattern. The application is then refactored using the design pattern. Simplified UML diagrams and easy to follow Java programs are used throughout the book. All of this is done is an amusing way that will keep the reader interested and not distracted.

I can strongly recommend this book for any developer with a sense of humor who wishes to understand design patterns. Even if you are not a Java programmer, the programs are simple enough for any developer using an object oriented language to understand. The book does a great job of explaining object oriented design goals and showing how each pattern fits into those goals. You won't find a discussion of every design pattern known but you will find a highly instructive discussion of some of the most common patterns. Reading this book will provide you with the skills to understand design patterns and to understand why you should be using them.

This earned 5 stars on Amazon. The book is published by O'Reilly.

This review and all my other reviews can be seen on My Amazon Reviews page.

Review - XML 1.1 Bible - 3rd Edition

XML 1.1 Bible
by Elliotte Rusty Harold

Elliotte Rusty Harold is that rare technical author who can write about anything and make it interesting. In this case, he has written 1,000 pages on XML providing us with an excellent guide book to this technology. Whether you are a beginner or advanced user of XML, there will be something in this book for you.

The book is divided into five parts. The first part discusses the basics of XML giving us an introduction to what XML is, what it is used for, and explaining the basics of creating a well-formed XML document. Part two discusses DTDs and explains how namespaces are used. Part three looks at various style languages including CSS and XSL. The section on CSS will be useful to anyone wishing to use CSS to format their HTML documents. Part four gives us a tour of some supplemental XML technologies including XLinks, XPointers, XInclude, and Schemas. The chapter that most interested me was on Schemas and the explanations were clear and complete, leaving no mystery about how to use this technology. The final part looks at a few XML applications including XHTML, RDDL, and SVG. The book does not cover writing programs to process XML documents using SAX or DOM, for example. The author has another book on that topic if that is of interest to you.

Each part of the book does an exceptional job of explaining the topic. The author gives us plenty of examples to make the text crystal clear. The author writes as a colleague helping out fellow programmers and not as an instructor droning away at a blackboard. You really get the idea that the author enjoys XML and enjoys explaining it. If you are interested in working with XML this book is truly an indispensable guide.

This earned 5 stars on Amazon. The book is published by Wiley.

This review and all my other reviews can be seen on My Amazon Reviews page.

Review - Lucene in Action

Lucene in Action
by Erik Hatcher, Otis Gospodnetic

Lucene is an open source, search engine library that provides a sophisticated API that can be used to index documents and provide advanced search capabilities. Although using Lucene is not particularly difficult, like many open source projects, the available documentation leaves something to be desired. This book nicely fills that missing area.

The book starts with an introduction explaining both what Lucene is and also what it isn't. The next couple of chapters show us how to use the Lucene classes to index documents and then search for those documents. The authors next show us how to improve our searches by using different analyzers including how to write our own custom analyzers. Custom analyzers can allow, for example, searches using common misspellings or words that sound alike. The book moves on to look at the advanced search features that are available to the developer as well as explaining how to add your own features into Lucene. Since Lucene works only with text data, the authors next show us how to convert various data formats such as Word documents, HTML documents, and PDFs into text formats to allow Lucene to index and search them. The authors wrap up the main portion of the book with a look at some of the tools and extensions available that can provide some nice additional functionality such as highlighting search words in the found documents. The final chapter is a look at some real-life case studies of Lucene contributed by various authors. Some of the writing here is rather weak and seems, at least in some cases, to be little more than ads for the various sites and products.

The book is very well written and gives a good in-depth exploration of Lucene. The authors give plenty of code snippets showing the features of Lucene and provide a complete application to review as well. Anyone interested in using Lucene and wants more than the little documentation available should consider getting this book. One thing that annoyed me about the book was the constant pushing of JUnit. Most of the code samples include some traces of unit testing and seeing blocks of code with "assertEquals" everywhere was distracting to say the least. The authors should have considered that not everyone is using JUnit and that when you are trying to understand code, additional off-topic lines are simply confusing.

This earned 5 stars on Amazon. The book is published by Manning.

This review and all my other reviews can be seen on My Amazon Reviews page.

Review - Murach's Beginning Java 2, JDK 5

Murach's Beginning Java 2, JDK 5
by Doug Lowe, Joel Murach, Andrea Steelman

The earlier edition of this book was a well written tutorial for the beginner Java programmer but it was also in need of an update. The release of the JDK 5 edition of "Beginning Java 2" attempts to answer that need. The new edition is almost 100 pages longer and the extra pages have been used to give greater detail on object oriented programming and to cover some of the new additions to the language such as generics. Unfortunately, the new edition contains too many mistakes and is less well organized than its predecessor.

A few examples of mistakes in the book will explain my complaints. In the discussion of abstract classes, the book tells us that subclasses of an abstract class must override all the abstract methods of the parent class. This, of course, is not true if the child class is also abstract. In the discussion of threads, the book explains synchronization of methods using a method that does not need to be synchronized. The explanation makes it appear that method variables are shared by threads. The book tells us that primitives are passed by value and objects are passed by reference. Of course, Java always passes by value although the value passed may be a reference. There are also problems with the sequence in which language features are introduced. For example, int and double are introduced early, but the reader must wait forty pages to discover that there are other primitive data types.

Overall, the new release of Beginning Java 2 represents a step backward in the Murach family of books. This book could have used much more careful editing and a better sequence of topics. If you are looking for a tutorial or textbook I can not recommend this edition.

This earned 2 stars on Amazon. The book is published by Mike Murach & Associates.

Due to a bug in the way Amazon does reviews, I can't publish this review on Amazon since I wrote a review of an earlier edition. My other reviews can be seen on My Amazon Reviews page.

Review - Murach's C#

Murach's C#
by Joel Murach, Doug Lowe

This is an excellent book for the beginning C# programmer. The book uses a "paired-page" format where the page on the left gives descriptions of a concept and the page on the right provides examples, syntax, and additional information. Although this does lead to some repetition, overall it provides clearer explanations of concepts that are laid out in front of you all at once. It also makes it easier to go back, find, and review information read previously.

The book starts with a tour of C# which leans heavily on Visual Studio. The first three chapters cover using VS.NET and very little C# code is presented. In fact, explanations of how to work in Visual Studio are provided throughout the book. The next two sections, covering 12 chapters, cover the details of programming in C# and writing object oriented code. The coverage of OO is excellent and it will remove much of the mystery associated with OO programming. Database programming using ADO.NET is covered at a good level of detail in five chapters. The final section covers reading and writing files including using the .NET classes to read and write XML files.

In many ways this book provides a level of detail not found in other books with plenty of code samples to help clarify the material. The only thing not covered is ASP and web forms. I can highly recommend this book to anyone interested in learning C# or to anyone planning to teach a C# programming course. The book is well designed as a textbook for a programming class. It includes objectives, a summary, a list of important terms, and programming exercises at the end of each chapter. A student workbook and an instructor CD are available.

This earned 5 stars on Amazon. The book is published by Mike Murach & Associates.

The review can be seen on Amazon on My Amazon Reviews page.

Review - Java Developer's Guide to Eclipse, 2nd Edition

Java Developer's Guide to Eclipse, 2nd Edition
by Jim D'Anjou, Scott Fairbrother, Dan Kehn, John Kellerman, Pat McCarthy

The first edition of this book was excellent for plug-in developers and helpful, although not vital, to all others. Two things make this new edition even better than the first edition. First, plug-in development in Eclipse is now so easy and so well explained in this book that there is no reason why anyone shouldn't be doing it. Have you ever worked with an IDE and thought, "why isn't this function available in the pop-up menu" or "why doesn't it have this feature"? Developing a plug-in will allow you to customize the functionality of Eclipse to provide the missing feature and this book will clearly explain exactly how to do that. Second, the section of the book that deals with developing with Eclipse has been improved with detailed chapters on team development including using CVS as well as an excellent example of integrating with Tomcat to develop an E-Commerce application.

The book is divided into two sections. The first 200 pages deal with using Eclipse and cover everything from the basics to complex team development issues. The next 600 pages cover everything you need to know about extending the functionality of Eclipse. The book ends with 200 pages of exercises that give detailed, step-by-step examples of using Eclipse. Five exercises deal with using Eclipse while the rest show examples of extending Eclipse. It is a big book that covers a lot of material but it covers it clearly and with plenty of examples. If you buy one Eclipse book, this should be it.

This earned 5 stars on Amazon. The book is published by Addison-Wesley.

The review can be seen on Amazon on My Amazon Reviews page.

Review - Hibernate

Hibernate: A J2EE Developer's Guide
by Will Iverson

Hibernate is a popular object-relational mapping (ORM) system for Java programmers. As any Java programmer who has worked with a SQL database knows, trying to link Java objects to a relational database is not a trivial exercise. Hibernate simplifies the task by providing an API and a set of tools that can generate Java classes and link seamlessly to a database.

The book starts with an introduction to Hibernate including some details on installation. The author looks at how Hibernate can generate a database schema or it can generate Java classes depending on where you are starting to build your application. XDoclet is discussed with the author pointing out some of the issues with using class annotation. After the introductory chapters, the author gives a good explanation of the details of Hibernate in the middle chapters. The last few chapters look at performance, caching, design issues and other advanced topics. Throughout the book there are many code samples that help to further explain the use of Hibernate.

I do have a few complaints about the book. Although performance is discussed, the cost of using Hibernate on performance is not. I would have liked to see some comparisons of Hibernate versus stored procedures, for example. Also, the weaknesses of an ORM are not discussed. Anyone who has worked with an ORM knows that at a certain level of complexity they start to fall apart and make an application overly complicated. It would have been nice for the author to discuss these issues and at least point towards solutions. Overall, the book serves as a well-written and clearly explained basic introduction to Hibernate.

This earned 4 stars on Amazon. The book is published by Addison-Wesley.

The review can be seen on Amazon on My Amazon Reviews page.

Review - SWT/JFace in Action

SWT/JFace in Action
by Matthew Scarpino, Stephen Holder, Stanford Ng, Laurent Mihalkovic

SWT and JFace are the graphical libraries developed by IBM as an alternative to Swing to improve performance of GUI applications (specifically Eclipse) written in Java. This book offers a thorough introduction to SWT/JFace. The authors avoid getting into a Swing vs. SWT/JFace debate although they do provide a comparison of the two libraries.

The book starts with a look at writing a program in SWT and then rewriting it using JFace. The authors compare the two approaches and give a good description of why you would want to use one over the other. The next few chapters look at the basic widgets, layout managers, event handling, and graphics contexts. Later chapters cover more advanced widgets such as trees, viewers, tables, menus, dialogs, and wizards. The last chapter looks at GUI development using Eclipse's Rich Client Platform. The appendices cover development within Eclipse and integrating SWT/JFace applications with OLE and ActiveX.

Overall this book does a great job of explaining SWT/JFace at a good level of detail. The book includes a reasonable amount of code samples as well as UML diagrams that help explain how these libraries work. The authors should have chosen a better sample application to demonstrate use of the libraries and there aren't enough screen shots included which may leave you wondering what some of the widgets look like. Other than these two minor complaints, this is an excellent book to learn how to use SWT/JFace and I can strongly recommend it.

This earned 4 stars on Amazon. The book is published by Manning.

The review can be seen on Amazon on My Amazon Reviews page.

Review - Core Java 2, Fundamentals

Core Java 2, Fundamentals
by Cay Horstmann, Gary Cornell

This is the seventh edition of this book and in some ways it hasn't changed much since the first edition. The first edition was aimed at C++ programmers who were looking to transition to the new language. The seventh edition is still fast-paced and detailed and aimed for the experienced programmer. This is not an easy-to-follow tutorial for the beginner programmer. The authors assume that you already know the basics of programming even if it isn't with an object oriented language. The book might make a fairly good college textbook but not as a first language.

The book covers the main areas that you would expect in an introductory Java book with a few surprises. The book gives a little bit of the history of Java and shows how to install and run Java from the console and Eclipse (but not NetBeans). There is an early introduction to reflection but exception handling isn't covered until well into the book. Swing is covered in a fair level of depth. J2SE 5.0 changes are covered throughout the book with the many examples written to show off the new additions to the language. Threading and Collections are not covered but rather are saved for volume two.

Overall this is a well written book but the target audience is getting small. How many C++ programmers can be left that don't already know Java? If you are looking for an introductory tutorial then this book may be a bit too advanced. Through seven editions, Core Java has changed little other than to reflect language changes. Perhaps it's time to rethink the franchise.

This earned 4 stars on Amazon. The book is published by Prentice Hall.

The review can be seen on Amazon on My Amazon Reviews page.

Review - Explorer's Guide to the Semantic Web

Explorer's Guide to the Semantic Web
by Thomas B. Passin

The semantic web is an intelligent web, that is, a web that can be intelligently used by computers. There are two things you need to know about the semantic web. First, it doesn't exist. Second, it may never exist. If this isn't enough information for you, and you want to look at what the future may hold in the area of an intelligent web, then I can't think of a better way to get an introduction to the technologies and ideas that may be part of the semantic web than by reading this book.

The author of the book takes the layers of the semantic web as proposed by the W3C and looks at each one in turn, skipping over the familiar XML and XML schema layers. The author starts with the RDF layer and gives one of the best explanations of RDF and RDF schema that you will find. RDF is the potential meta-data language of the semantic web and the author makes it clear and understandable. Other than XML, RDF is the most real layer of the W3C layer cake so this section is also the most accessible. The next chapter delves into ontology which is vaguer and less clearly defined. The chapter on web services seems a bit unnecessary except as how they fit into the semantic web. A chapter on how intelligent agents may work is included. The last section deals with how information may be verified for truthfulness and authenticity.

If you are interested in RDF then you may want this book just for that section. If you are interested in what the semantic web might look like then this book may be of interest. If you are looking for practical programming samples or ways to build intelligent agents then this isn't the book for you. This is an explorer's guide for those having no fear to tread into unknown waters. This part of the web is still uncharted but this book will help you learn what technologies may be used to fill in the missing pieces of the map.

This earned 4 stars on Amazon. The book is published by Manning.

The review can be seen on Amazon on My Amazon Reviews page.

Review - Building Portals with the Java Portlet API

Building Portals with the Java Portlet API
by Jeff Linwood, David Minter

Portals are becoming more popular as companies are looking for a single web-based entry point into their various applications. Java provides a standard portal model with JSR 168. This book is a thorough introduction into JSR 168 that will help get portal developers up to speed into this relatively new specification.

The book starts with an excellent introduction into developing portlets. The first seven chapters cover all the details of developing portlets. Response and request objects are covered in detail. The portlet life cycle is clearly explained. Deployment descriptors are discussed. Integrating with Servlets and JSPs is described. The remainder of the book covers more advanced topics. Anyone working with a portal knows the problems with providing single sign-on to multiple applications. The authors discuss this issue giving several examples. The authors cover syndication, searching, personalization, web services, content management, and more.

My only complaint with the book is that it uses the Apache Pluto portal, which is not in final release yet. Pluto is an open source portal but it is complicated to distribute content to it (you are forced to use Maven). When the book explains how to distribute portlets to Pluto it gets a little confusing because the authors need to explain multiple configuration files, some of which are exclusive to Pluto. Other than this one problem, the book gives a solid introduction to developing a portal providing detailed information of both the basics and many advanced concepts. Clearly the authors understand portal development and know how to pass that information on to their readers.

This earned 4 stars on Amazon. The book is published by Apress.

The review can be seen on Amazon on My Amazon Reviews page.

Review - Java Reflection in Action

Java Reflection in Action
by Ira R. Forman and Nate Forman

There are only a handful of books that every Java programmer should own. This book manages to enter into that elite group of books by providing exceptional coverage of an area of Java programming that is generally poorly covered and often misunderstood. Reflection is a topic that many programmers know about but don't truly understand. Reflection can provide simple ways to get out of complex problems, which makes it well worth knowing. Reflection is one of those tools that you never knew you needed until you learn it.

The authors of this book are a father/son team that have been working with reflection for years. They attack reflection in small pieces, making each topic crystal clear before moving on to the next. In keeping with the "action" from the title, the authors show examples of each aspect of reflection, breaking down each line of code with complete explanations.

The book starts with the basics of reflection, looking at how to examine a class at runtime and dynamically load it. The book then moves on to demonstrating how to use the Proxy class. Later chapters show how to examine the call stack, customize class loaders, and transform one class into another. Performance is covered with a chapter that gives some good examples of benchmarking the cost of using reflection. The book ends with a look at the impact of Java 1.5 on reflection.

The best advice I can give is, buy this book. You will be amazed at the things that you didn't know you could do with Java.

This earned 5 stars on Amazon. The book is published by Manning.

The review can be seen on Amazon on My Amazon Reviews page.

Review - Pro Jakarta Velocity

Pro Jakarta Velocity
by Rob Harrop

I have always been a strong supporter of Velocity. I even wrote an article for JavaRanch about Velocity back in March. Velocity is an open source template framework designed to simplify the task of generating content such as web pages, email, or any other text-based output. The Velocity documentation available from Apache is short, low on examples, and leaves holes (even if it is fairly good compared to some other open source projects). This book fills in the gaps and gives excellent coverage of the many features that are available with Velocity.

The book starts with an introduction to Velocity and then explains how to install and configure it. The author then discusses the Velocity Template Language, examines its shortcomings, and demonstrates how to get around them. Best practices are covered early in the book. Although Velocity is normally thought of as a web-based framework, the author doesn't let us forget that it can be used for both stand-alone and web applications and gives us detailed chapters on both. Velocity tools are well covered including Anakia, which can be used to transform XML. The Velocity architecture is explained as well as ways to extend that architecture.

The examples are well thought out and give good coverage of the features of Velocity. The most interesting part of the examples is how little work it is to integrate Velocity into a well-designed framework. The author shows how Velocity fits into both Struts and Spring, demonstrating that Velocity is not meant to replace these frameworks but rather to simplify content generation in any framework. I can strongly recommend this book for anyone interested in Velocity. For anyone not interested in Velocity, the question is, why not?

This earned 5 stars on Amazon. The book is published by Apress.

The review can be seen on Amazon on My Amazon Reviews page.

Review - Effective Enterprise Java

Effective Enterprise Java
by Ted Neward

As anyone who has programmed using Servlets, JSPs, and EJBs knows, the complexities of integrating multiple layers of code can drive you to distraction. If you aren't careful, you can create an application that performs poorly under load, is difficult to maintain, and is impossible to port from one platform to another. The tricks that a programmer needs to avoid these problems often come painfully with experience. The author has taken his experience and given us a book that is well-written, easy to understand, and provides plenty of excellent advice that will help you produce superior applications. The best part is that the advice you get is practical advice from someone who has actually experienced the pain and suffering of J2EE development. This book deals in the reality of development and not pie-in-the-sky theory.

The book contains seventy-five items of discussion broken up into seven main areas. The items cover a wide range of topics from the broad, "Keep it simple" to the specific, "Never cede control outside your component while holding locks." The items cover everything from architecture, "Define your performance and scalability goals," to coding, "Use HttpSession sparingly." Even if a particular item is not of interest to you, there will be plenty of other items that will be of interest.

This book is not a tutorial or beginner's book. It is expected that the reader already has some experience with Enterprise Java. If that describes you, make sure you get this book to avoid more pain and suffering. You will end up a better J2EE developer and your applications will be cleaner and easier to maintain.

This earned 5 stars on Amazon. The book is published by Addison-Wesley.

The review can be seen on Amazon on My Amazon Reviews page.

Review - Java Garage

Java Garage
by Eben Hewitt

Headache. That is what I got every time I picked up this book. Too cute. Too many short sentences. Sentence fragments. Headache. Recipes. Like reading my 12-year-old daughter's instant messages.

First thing to note is that this is a beginner's book. You won't find that anywhere in the description unfortunately. Second thing to note is that I blame this on "Head First Java". You know how when a successful TV show comes out and all the other networks try to copy it? You know how they never do it right because they always miss the point? It's as if someone saw "Survivor" and decided it was a success because people ate bugs so they made a show where people had to eat bugs to win. "Head First Java" uses humor to help focus the mind on difficult concepts. It makes use of educational techniques that have been studied by scientists. This book uses humor to be cool(?), funny(?) but most of the time the book is just annoying, which is a real shame because there is some good information here and some of it is very well presented. Other times I was left wondering why he stopped and didn't finish explaining a concept. Then there are these stream of consciousness blurbs that seem to just come out of nowhere and go on about anything except the topic at hand. I assume the author is trying to be amusing and be less like a traditional technical book but he fails at the former and overachieves at the latter.

At one point in the book the author suggests that if you still have questions that you should get some Zoloft and take up a hobby like gardening. I think it's a little odd for an author to suggest that his curious readers are in need of anti-depressants but if forced to read this book, it may not be a bad idea. cya.

This earned 2 stars on Amazon. The book is published by Prentice Hall.

The review can be seen on Amazon on My Amazon Reviews page.

Review - Java Studio Creator Field Guide

Java Studio Creator Field Guide
by Gail Anderson, Paul Anderson

Sun's Java Studio Creator makes use of JavaServer Faces (JSF) to allow visual development similar to the way Microsoft's Visual Studio allows visual development of ASP based sites. It is an easy to use IDE that allows you to drag and drop JSF components, validators, and converters to design a web application. Much of the code required for a web site is automatically generated for you as you visually develop and additional classes can be generated or hand written (depending on their complexity) using the tool. This book will not teach you JSF but it will teach you how to use the IDE and quickly create web applications. This book is a well-written and easy to follow step-by-step tutorial to using this new IDE.

The book starts with a chapter on Java that can be easily ignored. The next chapter gives a quick introduction to the IDE. The authors demonstrate many of the basic techniques and show how to use the visual features to create navigation for a multi-page web site. The third chapter discusses each of the JSF components that are available in the IDE. Chapters four and five demonstrate how to use these components to build a web application. The examples are simple but they show how to integrate the generated code with custom beans (that can also be generated). Chapters six and seven show how to integrate Web Services and databases into your application. Chapter eight looks at internationalization and writing custom validators. The final chapter covers debugging.

If you have a copy of the software and want to utilize it to the fullest then this book is well worth buying. If you don't have the software then look at ISBN 0131499947 to purchase the book and the software together.

This earned 5 stars on Amazon. The book is published by Prentice Hall.

The review can be seen on Amazon on My Amazon Reviews page.

Review - J2ME Games with MIDP2

J2ME Games with MIDP2
by Carol Hamer

I really enjoyed this book. The author does a solid job of explaining everything you need to know to write games for MIDP devices. If you are familiar with Jonathan Knudsen's book on J2ME (probably the best book on the subject), this book expands the single games chapter into a fun and interesting book.

The book starts with a quick sample showing us how to use the Sun IDE and how to run our games on the emulator and how to download our games to a phone. The author shows a couple of example games, a maze and a jumping game, that give a good overview of the basic techniques games use on MIDP devices. She then expands those examples by showing proper use of threads and shows how to play tones and music during a game. Storing information (such as high scores or user preferences) is demonstrated. Downloading game enhancements such as new levels for a dungeon game are also demonstrated. The book is full of well-commented code samples (worth stealing) that show the techniques being discussed.

The author of this book has a nice, easy to read style of writing. Her enthusiasm for the topic comes through and makes you want to try the many sample games. If you have been spending too much time on enterprise programming then playing around with some MIDP games might be just the antidote and this book will get you started on the fun.

This earned 5 stars on Amazon. The book is published by Apress.

The review can be seen on Amazon on My Amazon Reviews page.

Review - InstallAnywhere Tutorial and Reference

InstallAnywhere Tutorial and Reference
by Zero G Team

This book is an excellent guide to using InstallAnywhere no matter which platform you are running or how much experience you have with the product. This is the kind of documentation that you wish that the company would provide especially when you consider the price of the software. According to the introduction, the book was produced from the handouts that Zero G had produced for their three day InstallAnywhere course.

The book starts with a quick introduction and some screen shots showing what running an installer would look like from a customer's point of view. The authors next show a simple example of building an installer. Unfortunately, and this remains true for the rest of the book, no screen shots are included. This means that you must be running the software to take full advantage of the book. No reading this book in the bathtub. The book works well as both a tutorial and reference guide. The authors take you step by step through an exercise explaining each of the options even if they aren't used in this exercise. The instructions for each exercise are very clear. The use of the product is clearly explained while you are using it, which makes the learning "stick".

The book covers everything from the most basic installer all the way up to writing your own custom plug-ins. If you are interested in taking full advantage of the InstallAnywhere software and don't want to spend the money for three days of training, then this book is for you.

This earned 4 stars on Amazon. The book is published by Addison-Wesley.

The review can be seen on Amazon on My Amazon Reviews page.