Variants Books

This book starts off with great promise. There is a historical survey and a survey of available products. Then the Java equivalents of Lex & Yacc appear and you start to wonder if the author has accidentally set out to write a compiler rather than a decompiler. Strangely but truly, these tools are used to build an ultra-simplified decompiler for some subset of Java. It can't handle much more than straight-line code. Sure, it'll do loops. Sort of. But just add a "break" statement and you'll break the decompiler. How about exception handlers? Nope. Oh well. See other reviewers' comments on how it pushes-and-pops strings. No flow graph is ever built. No abstract syntax tree. If you've read a compiler textbook, you know more about the subject of this book than the author does. (IIRC, he admits this in the text. As another "reviewer" pointed out, the author was a journalist before becoming an expert on decompiling. You do the math.)

I think the author learned a lot by writing this book, which is great. And it's great that others can learn the basics from it too. But in the overall scheme of things, this is like a high-school course in decompiling. (Arguably, you could call it 'Decompiling 101' but that would mostly be rhetorical.) Someone interested in this obscure topic is likely to want to dig deeper than this book can go ... say, to be able to decompile some actual Java code, not just simplified examples in a subset of the language.)

I was tempted to give this book one more star because it's the only mass-market book on the subject of decompiling. But I was also tempted to give it one less star on the basis of its content. So it's somewhere between 1.5 Stars and 2.5 Stars. YMMV.

Better suggestions include buying the following from Amazon:
- Books on the Java Virtual Machine by Bill Venners and Joshua Engels.
- Books on decompilation and reverse engineering: "Covert Java", "Reversing".
- Books on optimizing compilers: there are lots of these. On that is particularly relevant is Steven Muchnick's book because includes a section on Structure Analysis ... those half-dozen pages (with code) get you a heckuva lot closer to a real decompiler than the one developed in this book.
- Online documents: Christina Cifuentes' thesis, papers by Laurie Hendren's group, etc., etc.
- The open source java decompiler, Jode.

Go Forth, and Reverse!

What I hoped to learn from the book was an understanding of modern Java decompilation techniques. With respect to this expectation, Nolan's book is a disappointment.

His implementation, though simple, will decompile only the most simple of byte code. Nolan points out that it is difficult to recover all legal control structures offered by Java, but is not so clear about the fact that this will never be possible with his approach (i.e. using syntactical analysis).

A stable decompiler which is able to produce clean code must do some control flow and structural analysis. The book gives no account here.

Regarding the other topics of the book such as obfuscation, legal issues, tool selection and case studies, there are more concise and cheaper books. Simply refer to Amazon's "Customers who bought this book also bought ...".

This is indeed (as other reviews wrote) a nice book about decompiling Java if you want to know how to write a very simple decompiler, but you need to keep in mind that the author uses a HORROR design/implementation.

The problem is this:

* You can download the sourcecode from the publisher website (so you can check my critism below yourself), but this code even doesn't have a license somewhere in the download archive!! Mr. Noulan seems not to be a pro.

* The author introduces a Class to XML converter, and tell the reader that the XML is the intermediate language. The problem is that in normal compiler design the intermediate language add something (else it's useless), for example the Intermediate language can be independ from the source language, but the Class to XML converter does not. It is just an another representation of the same data so it can be omited (but yeah it looks cool, saying that your compiler does something with XML) Maybe the author want to ride the XML 'hype'?

* The author knows how to write a simple Java decompiler, but he don't know how to write nice Java code. For example he uses different stacks in the decompiler, but he only pushes and pops strings from/on it. He then parse the string to retrieve the data he need (if the string contains integer, he parse the integer). As a result his sourcecode is filled with .toString() calls to create the string and .indexOf, substring, etc. to parse it back later (and he assume this always goes OK). What a mess. Has Mr. Nolan ever read a real compiler design book? If he did, he would choose to use a AST Tree. I need to make a note: maybe this String mess was needed to keep the code size (for printing in the book) small.

* The String mess is one thing, coding the whole compiler directly in the entire CUP parser file is something else!! What a great professional design. NOT!

So this is a nice book if you want to know something about how a decompiler could look like, but please don't use his ideas ever in a real (de)compiler!

This is a fantastic in-depth book on decompilers and code obfuscation tools for Java. It covers the structure of Java code files, the opcodes, and the all of the tools required to decompile classes, and to obfuscate existing code. It's an invaluable reference for anyone who has to deploy Java in a non-secure environment, or for those that want to learn how the language really works.

There is a lot of code to pour though, and there are no illustrations. I think the text could have used some illustrations, but that's not a big sticking point for me.

If you are a serious Java gearhead you should have a look at this book. And if you have a specific interest in either de-compiling some Java or obscuring your deployed Java bytecode then this is a must have.

"Decompiling Java" is an interesting piece of work. In just 250 or so pages, you'll go through legalities related to decompiling Java code, learn the basics of Java's class file format, get a brief run-down of tools available for decompiling and obfuscating Java code, all the way through different methods employed by obfuscation tools. Finally, Nolan goes through the design of a basic Java decompiler implementation using JLex and CUP open source compiler compiler tools.

The brevity of the book is both its best and worst characteristic. It's great because I certainly wouldn't have wanted a bible on copyright and patent laws in different parts of the world, but it's unfortunate because the topic you're interested in is bound to be slightly too superficial or detached from the rest of the book. For example, I would've liked to read a lot more about the actual class file format and the internals of a JVM in the book itself instead of having to read from a specification on the web. On the other hand, the author managed to light some bulbs in my head along the way and I actually enjoyed reading his text - especially the chapter about creating a decompiler using JLex and CUP (which I've also found a bit too intimidating to actually look into).

In summary, "Decompiling Java" is a good overview of decompilation in Java and it has a couple of real gems inside, but if you're looking for a manual for dissecting class files or the JVM, it might not the book you're looking for.

This is a well written book that covers the basics of Java Web Services according to Sun (i.e. from a Java perspective). However - things have moved on since the publication of this book 4 years ago. Will still be a good book to use for the Sun Certified Web Services Developer exam until the exam is updated. May want to look at more recent books.

This book is well written. It would be helpful if there were questions and the end of the chapter.

his book is primarily geared towards reader familiar withthe J2EE architecture. Code samples are few and far between, and the illustrations are primarily UML. That's cool. For a book from Sun J2EE team, I would like to see a little more code examples (thus the four stars instead of five.)

The book starts with XML basics, then spends the largest portion of the book on SOAP and JAX-RPC, then finishes off with an excellent chapter on security issues. There is some mention of mobile, but detailed enough.

I do suggest this book as a good reading for budding Java architects who want to learn more about this topic.

As the title of my review says this book is intended for all the people who want to architect and develop web services in a proper way. The technology around Web Services is very splitted. I mean from a lot of separate web associations. When you want to master web services technology you have to know in detail XML, XML Schema, SOAP, UDDI and its support in J2EE.
This book gives architectual overview how these technologies depend on each other, I mean the relationships.
The book is not intended for getting detail information about source code implementation. Anyway, it is from the SUN Blueprint program team. So everybody developing and architecturing web services with J2EE technology should read this book. It is a very dry book. Very talkative. I am glad I have already read it.

This book provides a very good, well ordered, high-level overview of architectural decisions in a Web Services application. If you have knowledge of J2EE technologies, and want an intro to the Web Services paradigm, this is a good book.

This is not a programmer's reference nor an introduction to J2EE technology.

The book is disciplined in maintaining a high-level overview; most code snippets are purposely contracted to show only the relevant features being discussed. This keeps the code snippets focused, but means that if you are looking for a sample SOAP document that does X, you'll need to look elsewhere.

I liked the organization of the book. Rather than organizing the book around an annotated sample application, the authors
take a more didactic approach; Chapter 1 gives an intro to Web Services, Chapter 2 reviews the alphabet soup of J2EE development and shows how various components either use the technologies or are connected by them.

The next five chapters each take one component of the Web Services domain and review in detail the architectural
decisions to be made in designing that component. In the chapter on Service Endpoint Design, for example, the authors review
two approaches to designing a service interface definition; should you first design a Web Services Definition Language or
should you first design the Java Interfaces? The Chapter on XML reviews the pros and cons of various XML parsers and the use of XML transformations for services which must interact with numerous systems. There are similar chapters reviewing Client design, Integration with the J2EE platform, and Security.

In the last chapter, the authors review their reference application and walk through their decisions.

Throughout, the authors give good advice on the judicious use of various technologies, use of Design Patterns, and designs that will give good, reusable code. The authors several times discuss patterns that will make the application simpler to understand and build upon.

All in all, this is a well written treatment that I highly recommend.

This should have been an excellent book. I bought it after carefully considering many other books with similar focus (including reading the Amazon reader reviews). I've been using DW since version 2 and certainly didn't want a basic primer. This book promised to zero in on exactly what I wanted: using DWMX to create dynamic sites with ASP.

All 5 authors seem to be knowledgeable and competent writers; a single author wrote each chapter. But IMO this book sorely needed editing for overall consistency and comprehensiveness. The whole is somehow less than the sum of its parts.

I suppose I was expecting something structured along the lines of Wrox's "Beginning ASP Databases": an ongoing, easy-to-implement tutorial that illustrates all of the theory in a consistent manner.

But the tutorials in this book were fragmented and difficult to follow, each one using different conventions, and often omitting information (which was sometimes found in later chapters but would have been useful earlier).

I'd love to see a second edition of this book that takes all of this information but presents it in a more cohesive manner. As it is, in order to set up PWS and get any of the examples to work, I had to rely heavily on other books and online tutorials (notably the Webthang tutorials for DWMX). It's been an exercise in frustration.

Being a beginner to the world of database driven web applications I found this book somewhat useful. My only major beef with the book is that in my experience using the tutorials and exercises and trying to apply them to ASP.NET, the screens and server behaviors didn't match up correctly leaving me scratching my head and randomly searching Dreamweaver's pull-down menus for the correct item to match my current tutorial step? Now I'm not sure if this book was just too early for the .NET world and I am trying to apply the latest and greatest technology to a inappropriate book or if the marketing for this book was just too ambitious? Overall a decent book, but don't bank on this being your "bible" if you are working in ASP.NET.

This book was a total let down.

I had great hopes when I scanned the contents of the book, but the whole book is badly written, and gives an overall impression of being rushed through.

There are far better books for creating dynamic sites with Macromedia products, and I strongy urge anyone to seek alternative reading.

Very disappointing.

This book is not for beginners. So if your new to data driven web sites, This book is not for you. Its starts of with just a few pages telling you about the new advances made within dreamweaver and just dives straight in at the deep end about the dynamic stuff. WHY CAN'T THESE AUTHORS WRITE IN A SIMPLE MANNER? They seem to assume that evrybody knows as much as them. Anyhow can I have my money back, please?

I went through this book and can now design dynamic data-driven ASP pages. Since Macromedia is focused on Cold-Fusion it is a relief to have a reference that explains using DreamweaverMX with ASP. There are more hosting providers available offering ASP hosting (at a reasonable price) than offer Cold Fusion (usually adds 20 or more US dollars a month to the base cost of hosting). So it is "cheaper" to work with ASP. I found this book to be very helpful and highly recommend this to anyone who wants to move from static pages to dynamic. It covers all the basics you would need to connect to a database and build recordsets and use the behaviors in DWMX. There is tons of info on the internet also. This book taught me a lot in a short amount of time and then I found all sorts of sites on the internet that had tutorials or free downloads. After reading this book I was able to understand the things on these various websites. I could then zero-in on a particular solution to something I was doing for a client's site and get the answer either from the book or from an online source. The foundation I got from this book has enabled me to dive deeper into DWMX and take better advantage of its many tools. I had a design background (Quark, Illustrator etc) and needed to make the jump to the "dark side" - programming and handcoding. This book de-mystified those scary subjects and I am now seeing lines of code in my sleep.

A very good book to start to learn Java (though currently a bit outdated). I am continuously using it when I have to find the basic ideas about a concept in Java.

Ten-minute approach is good to teach the beginners new tricks. They may learn general data processing knowledge later on. It is more attractive with few simple lessons on Stand-Alone programms working with files. I wish to buy some copies of the next edition.

You know there's something wrong with a book if the back cover claims it's the best one for programmers who've already learned C/C++ *and* the best one for people who haven't programmed before. Those are mutually exclusive goals; there is simply too much stuff to teach someone who is not a programmer that could be skipped if one is a programmer.

Secondly, you know a book about programming is going to suck if it doesn't cover input much -- this one doesn't until chapter 29 (the last one). Non-programmers, try to imagine a program that doesn't ask any questions of the user. It reduces your computer to a calculator, and little more, regardless of what loops/HTML it uses. It's simply not that handy.

I give it two stars because it is outdated, hardly useful, and highly annoying. It is, however, a good guide for absolute beginners who don't mind all of the miscellaneous problems. And it is (was) a good buy at ~$15. So, if you want to learn *something*, and all you have is $15, go ahead. Otherwise, find a better one.

Finally, and just as a kind of general belly ache, why do all programming books feel like they have to spend the first chapter telling you why that programming language is so great? I mean, you bought the book already, so it's not going to attract any customers. It seems as though they want you to memorize their propaganda for whatever flame wars you are expected to engage in simply for buying the book.

Another general gripe -- why do the people who write these feel like it is nessisary to say, "you'll be programming minutes after buying my book!" ? After the first one, most people realize that your first program is going to be the one that does absolutely nothing -- useful or for your ego. I find it much more amusing when I make a useful program on my own using a language I know well than when I copy one out of a book in a language I don't know.

This book is definately not 10 point material, but is nothing to sneeze at, never-the-less. Each chapter of the book was short, and simple, and you were expected to learn "why" something worked instead of just "type this blindly" (the teach yourself in XX days books use that method and I find it hard to LEARN anything from them) I really enjoyed the book and retained a lot of the information too! The biggest turnoff today for the book is that it covers jdk1.0.x thus some of the APIs are deprecated (this can be a good thing though, it will teach you how to use the API manuals to find out what replaced those deprecated APIs.. thus LEARNING) I too noticed many typos, but to look at the bright side, when I saw a typo it proved to me that I was actually LEARNING, and was able to point out errors made by the author themself.. in short, even the books shortcomings turned out to be vastly helpful!

I read this book 3 years ago, when I started to learn Java. While this book is not recommended for advanced users, I think it's the best one for a beginner, especially because it doesn't mislead You by favoring different IDEs (MS VJ++, Visual Cafe, etc.). I would also recommend Jamsa's book "Rescued by C++", to those intersted. Again, excellent book for college students or anyone new to programming.

Good solid Java book for beginner and intermediate level programmers. Good examples and explanations of the basics.

I just bought this book for my son, only to find out that the entire book is based on the J2SE 1.3 SDK which was end-of-lifed in December 2006 (for Windows and Linux) and is no longer available, so the book is USELESS (unless you happen to have a Solaris 8 box sitting around)!

AMAZON - STOP SELLING THIS BOOK!

OH - SORRY - you can get the 1.3 SDK for HP-UX if you have one of those!

if you have no Java experience, this book throws you into the deep end of the pool right away. I purchased 3 books on leaning java for a beginner. This was the most valuable in the long run albeit the most difficult. There is no hand holding and lots of good examples with few mistakes and lots of multiple examples within a single example (confused, read the book and you'll see what I mean). I suggest you get this book but if you need hand holding, also bur Burd's java for dummes to start with.

I bought this book and thought the programming projects in the book were awesome. All of the exercises are taught for use in game programming. While the author probably doesn't explain the language and fundamentals in depth (rather terse), he explains the fundamentals of how the games work. I've read Deitel's Java How To Program, and I recommend that to any Java beginners. If you want to learn how to program games in Java such as minesweeper, tetris, and others, get this book! It's awesome!

This is a really good very basic intro--but it won't get you to a level of Sun exam competency because it shyes away from some of the crucial distinctions you need to know--like multidimensional arrays.

If you have done a lot of work with OO design, and are designing SOA based systems, this book is for you. It does a brilliant job of explaining how SOA encourages a component Architecture style, rather than a Object Oriented design methodology. Some consequences of that include, 1) passing simple data structures and expecting simple Collections from Services, such as Arrays. 2) Using composition much more, rather than inheritance. 3) Separating the Business Logic (and process) from the Business Data, so that the business process can be exposed at a higher level of abstraction, and shared across multiple Activities that can fulfill the business logic.

This book is still very relevant, and a great read for Architects, developers and Managers.

I enjoyed reading this book because it discusses middle-tier issues well. Many Chapters (ex. "SOA Pattern" and "Service Directory Pattern") are good descriptions of WS, but are not Patterns.There is not enough technical info to implement a WS. There are issues with WS not discussed in this book. Therefore it is not a good summary of WS nor of their Patterns.

Perhaps Monday is attempting what Martin Fowler did some ten years ago, when Fowler wrote a now classic book on refactoring. Here, Monday identifies several useful patterns in WS usage. We're talking about a collective, distributed computation here. That is (or can be) usually asynchronous. Another book ("Remoting Patterns" Wiley 0470-856629) discussed patterns for a general distributed case.

But Monday focuses on what might emerge as useful within the strictures of WS. Especially if we use Web Services Description Language or Business Process Execution Language. In terms of example code, he chooses Java to express this. But the text makes clear that the patterns are of course independent of any given coding language. (The WSDL and BPEL and other WS variants are declarative languages.)

You may find the book useful if you are new to WS. It gives a higher level view of what might be done. Whereas other WS books could be concentrating more on the WS syntax. Also, you may find out whether BPEL is sufficiently expressive for your needs. BPEL was conceived in large part because WSDL ran into limitations. But BPEL itself needs a practical workout by developers.

Some of the fonts chosen remember me of some books I read 15 years ago. There are bad recommendations like promoting a distributed architecture in the "Physical Tiers Pattern". The chapter describe how you can communicate between two processes with RMI or CORBA.

The only two patterns that were not obvious for me were the "Faux Implementation" and "Partial Population", but few strategies are presented for implementing them.

In overall, the author seems naïve and not very experimented.

I've been architecting Web Services since before they were called Web Services, so I was really hoping to come away with some new insights based on the other book reviews here. Unfortunately, this book fell short in several ways. Pros: I liked the idea of WS patterns - it's a good idea and he did an ok job, I also liked how he tied the example application to the text. Cons: the writing style was a little dry and repetitive, very few of the patterns actually applied to how clients interact with services (something most of us that implement services are interested in), all of the examples used rpc/encoded SOAP messages which is pretty much an obsolete practice, and the author seemed to have much less Web Service experience than pattern experience. For example, in the Partial Population Pattern he recommends that clients use "keys" to identify parts of the message that they want returned. A more XML-friendly approach would be to use a limited form of XPath rather than keys, thus allowing for more flexibility. The pattern also assumes that the response schema allows variations in the message to be returned, something that I don't believe he discussed.

There is something fishy about this book. Some of the answers given for proposed interview questions are just plain wrong. The description of the author says he has some kind of Java developer certification but it doesn't use the right terminology for the Sun Certified Java Developer(SCJD). If he had the SCJD then he would also have the Sun Certified Java Programmer certification but they don't mention that one. Hey author, what's your SCJD certification number so we can look it up?

At one point the author cautions against hiring anyone 60 years or older because if the company provides full retirement benefits at 70, the company would only get 10 years work before paying for a full pension. Is that blatantly discriminatory or what? No wonder it's tough to get a decent job if you're over 50!

I was happy to have this book to serve as a guide during my interview process for a Java apps programmer position. It was well written with an insightful assortment of interview questions - both technical and non-technical. The questions on Java are relevant to all releases of Java 2, but would like to see an update that includes new features found in release 5.0. Other than that, a well written guide.

This is my second book from Rampant (Oracle Utilities being the first). Extremely well written with in-depth coverage of the language. I am a web developer moving from Perl to Java and glad to have so many questions and answers in my hands. Nice job!

I am a manager (and still developing, however as little as possible) for a group of developers working with Oracle Apps 11i and a custom integrated web application for our sales and manufacturing department. I own both the Java and the J2EE version of this book and will be cross posting my comments to both of them. The comments below are both mine and senior members of my staff that have gone through both books.

Both books contain very similar information with regards to the interview process - proper dress code when showing up for an interview, assessing job skills, the values of certification and formal education requirements.

The heart of both the Java and J2EE books, however, is the Q/A section. Both are filled with well written and insightful questions that could be used for many J2EE or Java candidate positions.

With regards to the Java book, I feel that there was fantastic coverage on key features of the language (threads, security, and collections) including basic object oriented design. I did find a few errors, some of which looked like typographical errors, but was able to located the errata on the publisher's site.

Generally speaking, both books are well worth the $$$ and I was very impressed by the quality (and quantity) of the Q/A section. I do see this book as an extremely helpful resource to any candidate preparing for an interview. Hopefully a newer version of this book will address some of the new features found in J2SE 1.4 and 1.5.

I used this book to prepare for an interview. Although I consider myself a fairly decent Java developer, I was amazed at some of the topics I had to further research. I felt that this book gave me what I needed to know and expect during an interview.

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.

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

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.

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.

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.

I agree with previous reviewers-- this book is not a whole lot different from Java tutorials. I'm a long-time java programmer, but with no 3d graphics experience. I found it difficult to pick up basic graphics concepts from this book. Thus, I bounced back and forth between this book, the java3d tutorials, and other tutorials I found on the internet. This book has some value in that it provides a handy reference for some aspects of java3d programming. But there are major gaps in explanation. For another option, try "Computer Graphics Using Java 2D and 3D" by Zhang/Liang

This is perhaps the most recent book on the Java 3D API published in the last four years. I started reading this one in 2004 and finished in 2006. Despite the number of years that have passed since it was published in 2002, I found it to continue to be relevant today, including my work with Xith, an Open Source API based on the public source Java 3D API.
"Killer Game Programming in Java", 2005, does cover some of the Java 3D API but there were a few gaps in it. This is understandable as it is written to cover all of Java game programming, not just Java 3D. I look forward to the release of "Foundations of 3D Graphics Programming: Using JOGL and Java3D", scheduled to be released June 30th, 2006.
~ David Wallace Croft, author of "Advanced Java Game Programming"

I bought because it seemed to cover the subjects in more details when Java 3D tutorial could not. However the Java3D tutorial of Sun is much more detailed and instructive when compared to this book. I extensivly needed Geometry Info sturctures info (i.e. building Shape3D s with custom points) however the book gaved the whole topic in a few paragraphs as it does in other topics.

There are no accompanying CD that include code, thus it is again harder to see techniques. The book is amateurishly composed, and the code examples are very difficult to read (no emphasizations, no bold lines, no comment highlightings...)

I recommend this book only if you can afford a book that will not help you much and urgently need a Java3D book.

This is the best book out there for any reasonable price that talks about Java 3D in any sufficient detail. All of the other books are either overpriced academic textbooks that teach computer graphics using Java3D, or they are earlier efforts that talk about eye-catching applets only. Yet, I am still not that satisfied. Java 3D is a complex API to use, and this book reflects that since it is a complex book that is somewhat disorganized, is too wordy, and doesn't really clarify how to program with the API that well. It does a good job of examining individual pieces of the API - textures, scenegraphs, interpolators - but never puts it all together so I can see the whole picture. One thing that it discusses pretty well that no other Java3D book covers is some topics on using the Java 3D API in virtual reality programming. For all other applications, and especially for beginners, you'll probably get more help reading the "Java 3D API Tutorial" provided by Sun Microsystems that is available online. The online tutorial does a better job of organizing topics and starting from the beginning than this book. In fact, I would really advise reading the online tutorial first before reading this book. You're likely to get more out of the book if you do.

The book covers a great detail for scenegraph construction and using the necessary features like materials, lighting, behaviours and animation. Especially the chapter for behaviours is very helpful in creating interactivity with Java3D.

There is only one weakness - geometry creation. Whether you create it inside Java3D or load it from industrial 3D packages, I think the official Java3D tutorial does a better job.

I concur with the readers who say this book isn't just an "intro to Glassfish", that it's more of a "summary of the components of the Java EE 5 specification with emphasis on how to configure and use those components specifically with Glassfish". And that was just fine with me, because I was kind of looking for both, and in this book I got both.

We considered Glassfish as a platform of choice for deployment of a revised/updated version of a sample application (for a new edition of a book). We wound up backing off from using Java EE 5 and stuck with J2EE 1.4, for a variety of reasons. In going through this book, though, I discovered it summarizes numerous aspects of Java EE 5 in brief, readable, understandable form. The chapters on JDBC, JSTL, JSF, JMS, and EJB3 were concise summaries that covered the material well and offered solid examples. Each of these topics has had whole books dedicated to them, so it's nice to see a book that wraps itself around these individual topics and conveys the essence of what they're about succinctly.

Usually the books that attempt to cover EVERYTHING in something as broad as a J2EE/Java EE spec call themselves "bibles", and indeed that's a good name for them as they attempt to be the canonical be-all and end-all on the subject with enough laborious text and sideline commentary to be considered "biblical". While none of the chapters here is a deep thorough tutorial, each one provides enough information for you to get your head around the topic at hand, leaving with enough understanding to seek out deeper information elsewhere. That's an important thing for a book like this to do, and it's not something to be scoffed at or dismissed. In my day job I'm working with JBoss 4.2 using Java EE 5 features like EJB3 and JMS, and this book provided useful information on those subjects clearly and concisely, and explained more than a few things to me that I hadn't gotten before. The chapter at the end on Facelets, Ajax4Jsf, and Seam provided very brief overviews of those approaches/packages, again just enough to explain aspects I hadn't understood.

I may use Glassfish in the future for personal projects, as it looks like it is a robust implementation of the Java EE 5 spec, and this book will definitely be a good guide to development and deployment of Java EE 5 apps for that environment.

I had pretty high hopes for this book but I'm pretty bummed out. It seems well written and I'm sure it is good for some people but just about everything in this book is available for free elsewhere. I wanted a book about GlassFish and really specific stuff like configuring a domain *in detail* and not a recap on how to run the basic commands. JNDI in GlassFish - I don't think it's covered. Writing applications with the Java Web Start and the nice appclient utility - not covered. Sure, most of that is mentioned (as in...the words are used) but basically this book is for people who want to learn how to write the simplest servlet, ejb, and web service and with the exception of the security chapter, pretty much none of it is really specific to glassfish. Oh well. I'll probably refer to this book on occasion when something isn't working and I want to check my sanity but for the most part this will sit under my much better books on EJB and JEE in general.

In under 400 pages, the author managed to do a pretty good job at introducing both what's in Java EE 5 and using it on GlassFish.

If you already know EE and GlassFish and want a specific topic covered in details, then you're probably better off picking a book on just that. Again, this book has JSF, JMS, EJBs, security, web services, and so on, but just enough to cover what most people will want and still keep it in a manageable number of pages.

Well worth my money - I don't regret buying and reading cover to cover.

My overall opinion of the book is good. The book is very well written, and the code examples in the book work. Working code examples are the number one criteria for me. The code examples start with some examples in Chapter 2 that are used throughout the remainder of the book. This provides a coherent flow through the book. You may also download the code examples from the Packt Publishing support site.

I would recommend it as a book to have on your development bookshelf.

The book claims to be the complete guide to installing and configuring GlassFish. I would not give it that much credit. There is room for more extensive books on GlassFish. There are a number of topics that are very general and have nothing to do with the actual configuration of the server. A better book summary would be a guide to installing, configuring, and developing applications for the Glassfish server. It is really a Java EE 5 tutorial which features Glassfish.

As a book on GlassFish, it is very light in its coverage. As a tutorial for developers acquainting themselves with Java EE 5 and deployment on Glassfish it is very good. In my opinion it is targeted at developers familiar with J2EE who want to switch to JEE5, or junior developers trying to get a better comprehension of the EE environment. It is not for novice programmers.

Chapter 1

Getting Started with GlassFish

This chapter covers getting and installing GlassFish. It is very basic, but will get you up and running. It also includes how to set up your JNDI database connections. The majority of this information can be readily found on the GlassFish site on Java.net. There is a good example of how to set up multiple domains on GlassFish which is not easily gleaned from the site. There is a chart which shows how the --portbase command line option is used to set the ports on which GlassFish services connections. This provides the best explanation for this command line option and graphically depicts what the results are.

Chapter 2

Servlet Development and Deployment

This chapter is a very basic tutorial on servlet technology. It includes writing a simple servlets, web.xml files, and deployment file layout (war files). It includes some examples on html forms, request forwarding and response re-direction. There is nothing GlassFish specific and the files will just as easily deploy on Apache Tomcat unaltered. There is one item of note which is sun-web.xml related which has to do with how to change the context root. This is used if you do not want the default deployment context to match the name of the war file.

Chapter 3

JavaServer Pages

This chapter again has a basic tutorial on JSP technologies. There is a really good example of creating custom JSP tags and how to use them. Again, there is nothing that would prevent the war files from being deployed on Apache Tomcat. I wish that the author would have covered Unified Expression Language (EL) in more detail. It is more central to this technology on JEE5 platforms.

Chapter 4

Database Connectivity

This is the first chapter which covers a really important topic in the enhanced JEE5 database access functionality, new Java Persistence API (JPA), and its reference application server (GlassFish). The first example shows a servlet and how to connect to a database using the old form of JNDI lookup without resource injection. The next example shows the simplified version using resource injection of the DataSource. This removes all the plumbing of fetching our data source.

The next section covers Java Persistence API (JPA) and provides an in-depth tutorial. This is a key concept in JEE5. It introduces the Entity annotation on a POJO to convert it to a persistable object. The simple example that follows it demonstrates correctly how to to use JPA in a non-thread safe environment of a servlet using a UserTransaction. It also covers the persistence.xml file.

This chapter is a must for anyone who wants to learn JPA. The sections on entity relationships, and composite primary keys are done extremely well.

This chapter concludes on Java Persistence Query Language (JPQL) which is the follow-on from EJB QL.It is very light. I wish the author would have covered this very important topic in more detail. That being stated, the code sample is a perfect example.

The book is worth purchasing for this chapter alone.

Chapter 5

JSP Standard Tag Library

This chapter is a basic tutorial on the JSTL. I found a number of syntax mistakes, which were submitted back to Packt. The SQL JST Tag Library is covered. It was very simple. There is one note on No Suitable Driver SQL Exception which is often a hard thing to track down.There is nothing substantive about this chapter.

Chapter 6

JavaServer Faces

This is another JEE5 technology that needs more coverage in general. This chapter provides a good foundation on the reference JSF implementation. It is very well written. I am a big advocate of JSF and thoroughly examined this chapter.

The introductory examples are well done and give a good overview of the technology. The example Customer bean is the same bean that is used in JPA in chapter 4. This shows the consistency and flow between chapters. In this case we use the bean as a managed bean in the JSF context.

The chapter also explains the changes needed in the web.xml file for JSF.

The section on validators is very well done. It includes an example using the Apache Commons Validator framework. The point is to show that you should look for good validators rather than creating your own. Roll your own for domain specific requirements. It also covers validator methods in some detail. It also covers another useful utility from the Apache Commons Language Library.

There is a section on customizing messages that provide feedback to the user on various validation errors. It contains a section on how to modify the default messages on GlassFish. It is nice to know how to do this, but I would encourage users NOT to do it. You can Google for the default messages to see what they mean. If you change them, that option no longer exists. Also it is not intuitively obvious where the message is coming from. There is another example using a message bundle for your customized messages. I would HIGHLY recommend using this method.

There is a wonderful section on integrating JPA and JSF. This is a must read, and covers the practical side of JSF and JPA. It uses a model-view-controller paradigm. It shows how to use the JPA as a managed bean that gets set from the JSF page and saved/modified from the controller servlet. This is an excellent example of how to do it.

Finally, the chapter closes with a reference to the JSF Core components. I personally believe that this should have been an appendix. It really does not contribute to the flow of the book, or chapter. I went through the reference with a fine-toothed comb. The examples are really clean. I submitted some errata for the section, but it was done very well.

This is another chapter that makes the book worth purchasing.

Chapter 7

Java Messaging Service

This is a chapter that has a very specific setup for GlassFish. Most of the previous chapters were general enough on the specific technologies that they could be used on Apache Tomcat. The JMS server setup which is covered for GlassFish is very specific to the server.

The first part of the chapter covers how to set up the JMS connection factory, and JMS destination resources (Queue and Topic).

The examples that follow are very well done on how to use the various topics and queues.

I was really impressed with the authors examples. They were clean. I questioned one of the examples on durable topics, only to discover that the author was correct.

Chapter 8

Security

This chapter seems out of sequence. The Enterprise Java Beans (EJB) and Web Services chapters follow it. I would have recommended it to follow those two chapters. The author does cover securing EJBs and web services which require a security pre-cursor, but it seems to disrupt the flow of the book.

This chapter was a big disappointment. The topic is covered in minimal detail. This chapter is so important that it needs more coverage.

Here are some of the major omissions:

* Setting up a SSL/TLS connection using a self-signed certificate, or CA certificate
* Setting up an LDAP realm
* Optional attributes for the various realms

There is coverage of the various realms with a focus on file and JDBC.

The JDBC realm is complex. I understand that setting up a JDBC realm requires more work, but I am not sure how many people would use this type of realm.

The file realm coverage is detailed, but I am not sure that any enterprise would use this arrangement. It is not scalable.

The example login form using j_security_check is very useful, as well as, the example LogoutServlet.

The certificate realm is covered in fine detail. It is one of the best examples of how to configure this setup.

The LDAP and Solaris realms are weak. There is nothing here but a placeholder explanation. I can imagine that most enterprise users will have an LDAP domain that they will connect to. This topic could have included an example using OpenLDAP with its configuration in an appendix, or using openDS (http://opends.dev.java.net).

The JDBC realm setup has a number of serious errors which were reported as errata.

The section on defining custom realms is ok. It glosses a topic which requires more detail. I would HIGHLY recommend using a pre-defined realm instead of defining your own.

Chapter 9

Enterprise JavaBeans

This chapter provides a good tutorial on the JEE5 EJB 3.0 technologies. It covers the use of the new @Stateless, @Stateful, and @MessageDriven bean annotations.

There is an excellent example of using a stateless session bean as the DAO controller for JPA. It is well done. This is followed by another excellent example of how to use DAO EJB in a web application using resource injection.

Transactions are covered in very good detail. There is an excellent table which explains the various types of container managed transactions, and the @TransactionAttribute annotation.

The real jewel of this chapter, in my opinion, is the section on Bean-Managed Transactions which includes an excellent example with all of the correct annotations.

There is a section on the new EJB Timer service. I wish they would have included a practical example, but the included example gives you a feel on how it works.

EJB Security is covered lightly. There is a great note about automatically matching Roles to Security Groups on GlassFish. It is a very well hidden feature, and one which I was not aware of. This simplifies some of the security mapping and is a great time saver.

This is another good chapter.

Chapter 10

Web Services

This chapter provides a good tutorial on Java API for XML for Web Services (JAX-WS). It has some simple examples, and demonstrates the great GlassFish web service testing facility built into the platform. The tester is a web based page which allows you to enter values and see the results, as well as, the SOAP messages (Request and Response). This is a real time saver and can help a developer check the expected messages quickly.

The chapter includes a section on how to include attachments and expose EJBs as web services.

The chapter concludes on a light coverage of web service security.

Chapter 11

Beyond Java EE

This chapter covers some alternative and complementary technologies for JSF like Facelets, Facelets Templating, Ajax4jsf (providing AJAX functionality to JSF applications), and Seam. The chapter includes some sample applications and how to install and set up these technologies.

Appendices

The appendices include coverage of using JavaMail and integrating GlassFish into various IDEs.

Again, I would recommend this book for anyone who wants to learn the basics of JEE5 programming with GlassFish.

I do have to agree with others who remarked that the book is not a comprehensive discussion of GlassFish. In this respect, it is somewhat of a downer. But, perhaps albeit inadvertantly, its best merit is elsewhere.

Over the years, the Java world has grown hugely from just the Java language. Roughly, the latter is more or less J2SE. But in the J2EE field, or what Sun seems to just be calling EE, many extra layers of code and packages have been added. Entire books have been written on each of the topics of servlets, Java Server Pages, Enterprise Java Beans, Java Server Faces, Java Messaging Service, JDBC, Web Services and Ajax. Where do you start, if you don't know any of these? One answer is right here. This book. Heffelfinger gives a concise overview of each topic. Enough technical details that a programmer can understand and appreciate. More to the point, you can see how these tie into each other.

Frankly, you'll still need those other books, to do serious coding in a given topic, or between topics. But the understanding and top level view here is valuable.