Variants Books

The book is rich in content and you can definitely learn a lot about JSF. Unfortunately, a good author also needs to be a good teacher and story teller. Reading Bergsten is like listening to Ben Stein or Stephen Hawking talk, you will undoubtedly wish you were doing anything else except this. Things such as changing a diaper or jury duty will become more appealing after reading this book. I stopped once during reading and decided to clean my room instead. That's exactly how exciting it was to read Bergsten.

To give a contrary example, Kevin Yank from sitepoint or Joe Burns from HTMLGoodies are infinitely more fluid and entertaining to read. If you want a book for its content, this is a good book. If you have a crappy attention span like myself, this is a difficult book to read. To give a bit of background on myself (not that anybody cares) I've been a Java programmer for about 6 years so the book isn't above me, its just too dry in my opinion. That's my two cents. Good Luck and Happy Shopping!

1/4 of the book goes explains how to use JSP, JSTL
2/4 of the book API reprint
1/4 of the book actual JSF stuff - not real world related - unless you know exactly what you are looking for you'll never find it...
i'm surprised this book went into print - probably somebody upstairs decided to have at least something rather than nothing.
waste of time and money.

I have this book and Core Javaserver Faces; this is the book that lies open on the desk, is dog eared, and has coffee spills on it. It's not perfect, but it's the best there is in this space.

I've been working on webapps for the past 3 years in PHP, Python, and most recently Ruby. I've been trying to learn J2EE and have found it very difficult to find a foothold, a solid piece of ground to get oriented as to how people write Java webapps. I tend to like tutorial-style books when learning a new subject, ones that pick a project and implement it step by step, explaining the importance and contextual relevance of each hunk of code along the way. Of the four or five J2EE books that I've read on O'Reilly's Safari, this book is by far the best one for my style of learning. Java webapps are unique in that there is such a wide variety of options for each layer of your application. The Model, View, and Controller layers are all completely independent, and the interfaces between them are all configurable. Not only are they configurable, but you can choose to implement the connections between layers in code, or by using xml configuration files. This is *very* different to any other framework that I've used, and the complexity and power it presents is immensely overwhelming.

Bergsten does an excellent job (in contrast to the Official J2EE Tutorial, imho) at presenting each concept with just enough background, context, and detail as is necessary for one to understand what is happenening at a given moment.

I really like the fact that all of the code is listed in its entirety in the text, with descriptions interspersed. I really dislike the style of tutorial that tells you to "download and install the source code" and then proceeds to discuss it. I find that by having the example provided to me, I tend to skip over the boring, but important, details and at the end of the read, I haven't retained much. I learn by "following along" and typing in the listings myself. It helps me to remember the concepts, and forces me to concentrate on what's happening.

I can't speak for how effective this book would be for someone who already knew J2EE in some capacity, but for me, a J2EE newbie who likes a hands-on, applied approach, this book was the perfect fit.

This book is an "OK" starting point for someone learning JSF.

Here are some things to be aware of:
1) Does a poor job explaining the lifecycle of a JSF component; he writes the sequence of events out in paragraph style and does not provide diagrams (UML or otherwise) to help with the illustration

2) Constantly switches metaphors as he is explaining JSF; sometimes he will be talking about the implementation view of a JSF component and then other times he will be talking about the application view of a component. It would be better if there were one or two chapters that focused on the "how the heck does this work behind the scenes" and the rest of the book focused on applying JSF.

3) There are syntax errors throughout the examples; this includes the code examples (.jsp examples) and the configuration examples (web.xml and faces-config.xml). To his credit, he constantly references the appendix section for a more complete example. As a reader, I personally don't like flipping back and forth all the time.

4) His coverage of the application (using JSF actions) is very basic (academic). He doesn't go through the academically classified edge-cases, which is disapppointing because those are typically classified as real-world.

5) He forward references way too much; for example he will talk about / use something in say chapter 4, and then states something to the effect "oh, we'll come back to that later, don't worry about it now". From a learning perspective this is terrible. It causes your train of thought to be derailed and you end up asking yourself the question "what does that do?".

On the positive side, the flow does seem to make some sense from a learning perspective. He builds on the foundational concepts and frames the learning in the context of creating a "real-world" application.

I understand this book is a bit out of date (suprises me O'R hasn't encouraged an update). My suggestion is to buy this book used.

The intent of the author is good, i.e., providing a workshop for people who are learning GoF design patterns. But result is disappointing.

First of all, design pattern would lose most of its values (or at least it is hard to appreciate its value) if there is no design context and forces that constrain or influence the solution proposed by the pattern. The context and resolution of these forces will let the reader/designer the see the value of how a design pattern fits in and balances the forces and maintains a level of flexibility. However, each chapter of the book provides little context for the design challenges.

Secondly, I don't understand why the author picks fireworks industry as the background for all the examples in the book, it is an area that most people are not familiar with. I know design patterns are not domain specific and can be applied broadly, but knowing the background of the industry in the examples is definitely helpful for readers. And all those examples are very boring, and sometime ridiculous.

Thirdly, the author tries to provide some pattern refactoring examples, but does a lousy job compared with Joshua Kerievsky, the author of "Refactor to Patterns", who provides clear steps to refactor from an existing causal (bad) design to a pattern. Particularly, what are the problems of the existing design and how a design pattern will solve those problems.

Overall, I am sorry to say that the author's mission failed terribly for such a good will.

I needed this book for a class. It was one of the worst books I have read. The first big problem is that every example is about fireworks. I found myself often struggling with firework concepts to understand the book. The second problem is that the book continually has questions/problems with the answer in the book. Before the concept seems to be fully explained, it is asking you to complete a diagram. I want the book to show me example, explain it and then test me, not test me beforehand.

There is no point to buy this book if you already have the book of Gang of Four. Good help to understand all the patterns is using simpler examples than what Gang of Four used. Unfortunately, this book was unable to take the advantage of Java language to use simple examples to illustrate the point and concept of each design patten.

One star might be too mean. However, if we are saying what someone already did, it would be better to use simple examples and make it easy to understand. Otherwise, what's the point?

The idea behind this book is a very good one: teaching patterns avoiding excessive formalisms and with a hands on approach. I had great expectations from this title which were only partially met.
The book content is sound and some of the patterns are explained in a decent way, but the workbook approach fails as most of the questions are unclear or just too trivial. I find the choice of using a firework factory to work out all of the patterns weird at best.. it makes for a very boring sequence .. fireworks might be fun to see but who cares to learn about star presses, fuses and chemical batches? Besides squeezing all of the patterns in a single context makes for a very forced result. And how about all the swing code thrown in without a real reason? It is just distracting. The author is certainly competent, and a sharp programmer, but he could not resist the typipcal geeky tendency of making things more complicated than they really are by throwing into the discussion basically everything he likes or knows about... parsers, state machines, swing, recursion, object models etc etc.. not to mention the damn fireworks.. ! ;)
I am still looking forward to a book that offers a clear , no frills explanation of design patterns and presents for each pattern a series of ( a lot of ) examples from different context. That is what is n eeeded to absorb good object oriented design and patterns.. simple, clear explanations and practice, practice, practice. Meanwhile, before you go for "the book" (Design Patterns by Erich Gamma, et al ) I would recommend reading
Design Patterns Explained by Alan Shalloway.

I would recommend buying Joshua Blochs' "Effective Java..." and you will notice that there are many concepts that Bloch advises against and such concepts are recommended in this book.

I think it is a total waste of money.

I agree with most of the other reviews the book is a little disjointed but it does a better job of explaining Eclipse than the confusing on-line documentation. However I was a very disappointed that it did not cover any of the CDT (the C/C++ development tool) which in my opinion is just as important as the JDT (Java development tool) I switched to eclipse in order to have a common cross platform editor for Linux/Windows/OSX and I also wanted that for cross language development but the CDT was never touched upon.. grumble grumble...

I found this book very helpful in navigating through Eclipse. Be sure to check which version of Eclipse you have; there are differences that can lead to confusion for first time users.

I stumbled onto Eclipse from a very unorthodox path. In my concurrent Java programming unit I continued to have problem in getting students to address all issues of import in their assignments. I thought that I should write a progressive series of programs to address one issue at a time. In class we were relying on command line compilation and execution of the Java programs.

To develop Java programs, I downloaded Eclipse IDE and started to write programs one project for each set of progressed specifications. Soon I had some 10 projects with 10 sets of codes. Eclipse was great, it allowed me to debug and see activities even in multi-threaded execution of programs. However, I wanted to have some transition among my 10 projects to be smooth. I wanted to use consistent interfaces, shared code for classes and comments. I wanted to learn more on refactoring functionality of the IDE. I bought the book to fill this goal.

Have not found much to help my goal but the book has exposed me GUI builder ideas V4ALL. But this project seem to be already gone. SWT was also a new exposure. I have not yet explored it but would it be acceptable replacement for Swing for a university course?

Over all the book is nice and easy introduction to using Eclipse IDE but much of what it introduces can easily be learned from the Eclipse help, tutorials and commonsense. It is time that the author be magnanimous and put the book on Web for all Eclipse beginners to read and adapt the tool. Good book but I am not sure if I can ask my students to spend money on purchasing a copy. An update to reflect the current state of the IDE would also be welcome.

Time has started to diminish the value of this book. Chapters 6, 7, and 8 deal with building GUIs using the V4ALL Eclipse plugin, which is now classified as Obsolete. Also with Eclipse 3.3 now available (the book focuses on Eclipse 3.0), a new edition of the book is definitely needed.

I bought this book and have been making my way through it to teach myself about Eclipse. I did fine for the first five chapters, but after that the trail grows cold because the book is based on Eclipse prior to the 3.0 and later releases. I began having lots of problems because the instructions and screen shots no longer came close to matching what is actually in Eclipse 3.0. So I gave up after chapter five.

I'm a college student working on a programming degree and I will say that this book is EXCELLENT!!! Featuring an easy to follow no non-sense format, I would recommend this book to anyone who wants to learn Java without the complicated text book aspect!!!

This book was the first one I ever read about programming. It launched a whole new world of logical and complex thinking that I could never have understood without the magnificent touch that the author gives us. He applies very simple examples to explain very complex matters about programming instances adding humor and intelligence... what else would you want?
It's simply excellent. 110% recommended.

This is great book for beginners, and you have to get other one to get to intermediate level. Read it before you get some theoretical book like Eckel's. Good for people who already have idea about what is class, object etc.

The book is a great primer for Java 2. Have been using it as a home schooling resource. The concepts are explained clearly, in a manner that teens from age 12 can easily grasp. The humor that peppers the text keeps them looking forward to daily sessions. Chapters and sections are sized so that you can take in a little or a lot at each reading. Coding examples helping to provide templates for your own programs.

We added in some home-grown practice assignments and got teens who were writing programs in a manner of weeks and enjoying it.

In addition, having an email address to send questions to and get quick turnaround responses is a great benefit for learning. Mr. Burd most obviously knows his stuff.

I've read a couple of other reviews and would like to clarify something here: In order to completely understand this book, you need to first read Barry Burd's prequel, "Beginning Java Programming for Dummies."
You can read my review and others on that book. It was a breeze. But this review is for Java 2 for Dummies. Although I have learned much from it, it does leave me wondering why he hardly ever references his earlier book. The first review I read gave this book a one-star review. I think it deserves a little more from a perspective of a person that read the earlier book.
If you're considering buying this book and do not own or have ever read Beginning Java Programming for Dummies, then this book is not for you. You must absolutely read that first, because every author and teacher has a different way of teaching.
In this case, it is more difficult because he is entirely bringing up a new subject. He intorduces Java to an absolute beginner like me very well. But the thing is, he does it in his own way. If you learned basic Java from another source, chances are they taught it in another way. You will feel confused because you aren't continuing the flow of his teaching.
Overall, here's what I think of the book.

1)Good-The author continues his prequel, Beginning Programming with Java for Dummies, in an elegant, easy-to-learn way.

2)Bad-He doesn't present it in a way that any beginner Java programmer can pick up on, only for ones who have read the prequel or other similar teachings.

3)Good-He introduces necessary pieces of Java perfect for the intermediate and gives you the skills you need to create simple to more complex programs from web applets to a sophistocated game.

Overall, I would like to give this a 3-star rating, but the content of the book presented in such a way urges me to give it four stars.

I've looked at many HORRIBLE Swing books, This one is great and recommended for anyone that is interested in doing anything practical with Swing or Java GUI's other than making a colored triangle in an applet window. I cant stress enough.. BUY THIS BOOK! i'm surprised this didn't have at least a 4 and 1/2 stars.

A compliment that I use to work with this book is the Core Java Fundamentals vol.1.

3.5 stars

Having used the book a number of times I find it an excellent first reference for doing most relatively simple to intermediate things with swing. It has excellent organization and index so finding what you need is quite easier and fast. There are many code samples- snippets, not full listings- showing how are use the major and most heavily used features of most components. It is also written in an approachable and helpful manner. It disavows exhaustive coverage of every single feature ( Try Swing by Robinson and Vorobiev- ISBN 193011088X for that)

This book is not a tutorial on java. There is no overview of the language. There is a disc with code listing. The style is generally of a bunch of small, self contained lessons on how to use a component- hence the usefulness as a first reference (at the cost of cohesiveness and an overriding arch). Where it falls down is when you progress beyond beginner-intermediate level with swing and want major coverage of obscure features. This probably isn't a problem for most of us not needing to attain guru level swing-skill. I think a solid example on how to use the MVC pattern (Model View Controller where Swing addresses the View) would have been a nice (and appreciated!) addition. From personal experience there is a tendency to put too much Model in the View rather than separate them out so changes/updating through versions is simpler. Learning this lesson is a must for anybody working with GUI's.

At times too there is the annoyance of not including things you would consider necessary, for example an explicit example of a combo box model and so forth. This devalues the work to some extent. A brief reminder of annoymous inner classes (as event handlers of choice) should also be included as too perhaps some mention of threads and thread safety. Thus the book requires a certain level and certain approach. Just remember it isn't a step-by-step, "let's build an application" tutorial through Swing.

So overall: a good book to start with and keep handy as more of a easy reference than a tutorial (I like paper references rather than online ones so I maybe baised in this respect). It's light on some areas, particuarly higher level and greater depth stuff. It starts at a reasonable level if you have some experience with Java (a typical book like Core Java by Horstmann covers easily up to and enough Swing to get you to the point where this book is a reference rather than a how-to). As a how-to for a novice I think it may be beyond many of them. Swing: A Beginner's Guide by Herbert Schildt may be better in this regard. If you don't mind the short, sharp discrete (disjointed) approach to concepts than you might not mind this. Otherwise it may be frustrating.

The JFC Swing Tutorial Second Edition is among the very best how-to-do it programming books I've read---and I've read scores! For this reason, I felt compelled to write a review of the book, admiring its organization, applauding its authors and encouraging progammers who need to to write Java GUIs to hurry up and by it. But then I read Thomas Duff's review; I became redundant. My recommendation is to read Mr. Duff's excellent review---knowing that I agree with every word of it.

This book has a great potential to be instructive, however, i give it a one star because it fails miserably in the delivery. The book has one full example in chapter 2 then after that all the examples are from the CD and the information about a particular issue such as comboboxes for example is strewn with code snippets that only address the most basic information; but when one looks at the full example from the CD, it contains much more in depth code that goes beyond the scope of the particular lesson. This left me with a confused situation. On one hand i have a very basic example that only shows the bare minimum of how to use a component and on the other i have code that introduces methods that are not very pertinent to the example and require more explanation. If it is pertinent then it should be explained fully which is not.
The book has great potential. For me, i would rather see the full examples at the end of each chapter or at the end of each lesson where the code snippets reside. This would be more helpful to me as i could study the full code without having to go to the CD or its copy in my drive and navigate through the way nested tree to get to each example. Thus one star.

This tutorial is well laid out and thorough. It looks suitable for learning Swing (I'm already fairly proficient) except for beginners to GUIs. It's also well organized as a reference work. It's much easier to understand than "Java Swing" from O'Reilly.

Of course the "down side" is that all the material is available online for free. So as an individual you can judge -- if the free online version is suitable for you then go for it. If you want something for your bookshelf or something you can write on and add bookmarks, well then shell out the money for the book. A CD in the back contains all the examples, so you won't need to go online for anything.

Ironically, unlike some earlier reviews (of the first edition) I feel the book is now better organized than the website.

The careful reader will observe _Core JSP's_ chapters and examples extend further into areas of in-the-trenches applicability more than any other book on the subject. It's sitting on every one of our programmers' shelves.

At first this book seemed great, but now that I have had to work a lot with JSPs, I have seen some serious shortcomings. The TagExtraInfo class get's way too little coverage. The book doesn't even begin to explain how to actually use it in real work. That's a serious shortcoming.

I only just started this book and I am already frustrated. No instructions on how to get the software you need or how to use it. The versions on the CD-ROM are outdated meanwhile. But what is really bad, the first "useful" JSP script in chapter 2 is already so full of code errors that you cannot run it! It took me hours of debugging before I made it run - how are you supposed to be debugging the stuff you are supposed to learn from? I will try to read a bit further but probably have to get another book.

The book has a lot of information about a lot of things but never nails down the subjects completely. For example, the book states you can do this, that and the next thing but never actually guides you through it.--> I guess you gotta spend [more money] to get that information. Another example is Chapter 11 on Custom tags. I read that chapter three times and still didn't get the point until I read some other literature on the subject. After that ordeal I felt as though my head had been used as a speed bag!

I also have found errors in the code and that should not be. Don't these authors have someone test the examples before they put out the code?

I wish the authors of computer books would just get to the point when they are trying to explain a subject(much the way Herbert Schildt does). I went through about 70% of the examples and found better ways to accomplish the same tasks on my own with less code. Learning programming is not difficult if the material is presented in an appropriate manner, however, this book will remain on my shelf and probably never be opened again.

My advice -> Try another one!

This is a good book under any circumstances, and if you develop with Oracle, it is even better, because there are many examples of JSP and Oracle JDBC, and while JSP/JDBC is intended to be database independant, it is easier to learn when the code is written for the database you use. There is a lot of useful information that will help you speed up your connections, pooled connections (which Oracle supports), and techniques for using synchronized statement to protect them. Synchronization is familiar to thread users, but well explained if you aren't familiar with the concept.

One thing the authors omit is setting autocommit off after making your JDBC connection. The idea of autocommit is to make JDBC "friendly" to certain non-Oracle databases, but if you understand transactions, you want to control when a commit occurs, and undo the entire transaction if you don't like it. To quote Tom Kyte, you never want to commit until you have to (slows database down) and you never want to commit part of a transaction. If your procedure should just update a single row, you can check the result before you commit. Setting all the banks accounts to zero may not be a transaction you will chose to commit. Checking a result is easier than explaining one. This is the kind of database specific information that perhaps authors writing for many platforms should ignore, but you may find it useful if you work with Oracle.

The authors show you how to use bind variables with prepared statements, and callable statements, but don't really go into the downside of not taking their advice; if you don't use bind variables, you will not have a scalable application. A lot of JSP examples (even in Oracle documention) do not bother with bind variables (example code is shorter if you don't) but "Core JSP" shows you code that is proper for scalable applications, and you can follow it (use the examples you find elsewhere as concepts, not as code to put in your applications).

This is a tiny portion of what this book will teach you, and if you are new to JSP and want to get a non-trivial application working, and scalable, this is a good place to start (also this is not an expensive book, which helps). This is all you need to get started, and see the value of JSP.

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.

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.

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

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.

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.

I like Eric's books normally; but this one is a bit dated and not much more than a review of the J2ME specification, which you could obtain on the internet without buying the book.

Lots of spec stuff and very little 'how to...' stuff. Give it a miss and buy his newer book with Ortiz as the co-author.

Although this book was published about a year ago, it still has an incredible value to everyone seriously interested in developing applications in J2ME. It is one of those few books that is capable of covering major topics without being too broad and digging deep into details without being boring.
Eric explains how to think in Java in J2ME. The thing is that normal Java programming paradigms often will not apply to J2ME, since we have to work in a very constrained environment. The author from the beginning gives you an overview of what can be done and what should not be done with J2ME. Those first chapters are worth the price of the book alone. Subsequent chapters cover the essentials of J2ME for different hardware platforms including Palm OS.
All in all, I think this book is a must for everyone who intends to write professional software for mobile devices.

This book is an excellent presentation of the current world of Java in embedded devices with enough detail to get someone started but also not too much detail to get a reader confused. It provides a great mixture of background and hands-on information. In a very structured way, the author shows the problem space of resource restricted operating environments and provides some guidance on when employing Java in a device makes sense and how to tune and address performance issues. After an overview of the J2ME specifications, three actual implementations of the CLDC/MIDP are discussed in detail (Sun's KVM for Palm, Motorola's J2ME SDK and RIM's Blackberry JDE). All of those implementations are included on the CD, which allows for some really good hands-on training. As an additional goodie the book also discusses Waba.

Generally, the tone of writing is very friendly making this book a very pleasant reading experience. The bottom line is, that this is an excellent introductory book to J2ME for people who know some Java already!

I definitely cannot agree with some other reviewer's perspective in regards to the author just having collected the Tech Tips he wrote into a book. However, this book together with the Tech Tips make a great combination to jump start J2ME development.

This book is an excellent presentation of the current world of Java in embedded devices with enough detail to get someone started but also not too much of detail to get people confused. It provides a good overview of the problem space of resource restricted operating environments and performance tuning. In a very structured way, the book describes the J2ME specifications and discusses CLDC implementations from Sun (KVM for Palm), Motorola and RIM. As a little goodie the author also describes Waba. Generally, the tone of the book is very light making it a very pleasant reading experience.

As a bottom line, this book is extremely recommendable for everybody with Java experience who is new to the embedded Java space!

This is a great book to help you get a handle on the Java2Micro Edition. Need to know the difference between a Profile & aConfiguration? Wondering where PersonalJava fits in with regards tothe J2ME?

The weakness of this book is the 'code' aspect. Theauthor goes through various implementations with a Tic Tac Toe game,but fails to go through in any detail of the main API's that aren'texactly in the J2SE (Records, Connector, how to draw low-level, Highlevel GUIs, etc..). Also, after reading this book it failed to mentionwhich DataStructures are available. Also, the detail of theimplementations is either slightly out of date, very light orboth.

Besides all that, it is a good book (hell it's the only J2MEbook that I know). For an overview book you couldn't ask for more.Easy writing style and helpfull diagrams, but not overdone. I wasinspired enough to write a J2ME game...

This is the Pattern book that can be made compariable with GoF's book -- Detailed and clear explanation of 23 patterns plus some system patterns. The full code examples can further illustrate the concepts in a modern view and benefitial to technical pattern design. Though it's Java approach, it can still work in other OO-related projects.

For the developer LEARNING Patterns, the Heads First book seems the most popular. But this is essential as a reference book. Premier examples, plus it reads more like a book and less like a math book (as most coding books are).

I open this up from time to time to keep those patterns not used often fresh in my mind to ensure I will realize when one is needed.

This is the first book that I go to for anything patterns, and I have a copy at work because my coworkers also come to this book when they need a refresher or reference.

Just shortly: Book contains all patterns from GoF book. Patterns are explained in more appropriate way and more closer to Java. Also examples are pretty simple and easy to understand. So the simplicity would be the best about this book.

I also like that the the second part of the book: "Patterns in the Java Programming Language" where the author covers extra patterns used in J2EE which I find very usefull !

I would like to see a CD or FD attached on the end of the book, although full code samples are also good (you don't need PC while reading the book). There is a web site to download examples and images and all fits on one single cheap floppy.

Anyway the best pattern book for Java I saw. I have many Pattern eBooks, but all of them are either too simple (can't really learn how to use the pattern), or too complicated (e.g. GoF is complicated for me). So this remains the best for me.

After reading this book, I did not see the author tried any new way to explain how, when and why to use design patterns. I don't think the book is worth the moeny I spent buying it.

I got the book before I had read the GOF book and found it quite useful. After reading the GOF book I found it even more so - I like the simpler examples and the fact that they are done in Java. Some people will not like the code reprint at the end of the book (about the last half of the book) - however I do, as it is quite convenient for referencing. Found the UML diagrams that were downloadable from the web reference site quite helpful.

The major problem with the book are the errors! The first pattern I looked at (Visitor) had an extraordinary number of errors. In the text it gave the methods one name and used another name in the code listing. Two of the classes for this pattern the code was simply duplicated from a third class. The downloaded examples did have the correct code. Be nice if there was a CD - but this is no major issue.

I would give it a 2 star at best, due to the errors, but if you can sift through the errors I think you will find it a nice supplement to the GOF book hence 3.5 stars (if I could).

Pankaj Kumar definitely deserves an "A for effort". As in other material of his I've read he makes security concepts accessible and easy to understand.

Kumar created an impressive array of tools and example code which are available at a URL provided in the preface. The problem is that when you consult his book hoping to find Java code to accomplish a specific task you often find instead a description of how to use his JSTK (Java Security Tool Kit) to accomplish the task. For some readers this may be okay but for anyone who wants to learn how to write their own Java code it just adds an awkward extra layer of indirection.

Aside from that significant concern I would definitely recommend this book for software developers seeking to learn more about J2EE security.

This is one the best books that I have ever read. The writing is very lucid and the author explains concepts in very clear and easy to understand manner. The utility tools are very, very useful. I have have been using them on a regular basis. The book also has good code snippets, diagrams and screen shots where necessary. But no space filling techniques ever.

The coverage of topics is very good. Security, cannot have one sided view. The author did a good job of pulling together all aspects of securing a Java application (from code access security and class loading to cryptography to securing components to securing webservices) - he covers the whole gamut without getting lost.

Ever since I bought this book, I have been carrying to work everyday. I buy LOT OF computer books, but rarely do I fall in love so much with them. I would put it on the same level as UML Distilled, J2EE Patterns and Bruce Eckel's Java. If you are doing Java Security, this is the one and only book you will ever read. To me, it has been inevitable.

I sincerely thank the author and the publishers for not making this another 1200+ page book. This is about 400+ pages and doesn't put you off with its weight!

This book is an excellent compilation of security concepts explained in simple terms and with lots of well illustrative example code. Kumar has even provided benchmarking code to help developer choose appropriate technology for their own applications. Great book to have for security developers and students!

This book is similiar to sun java security tutorial with little additions specific to weblogic 7.0 and apache axis 1.0. The code examples don't run on j2ee 1.4 platform. The book also needs a new edition with revised examples to include newer security mechanisms with j2se 1.5. Except for chapter 1 - A Security primer, all other chapters are technically obsolete.

If you wish to pick a good alternative book, choose Core Security Patterns by Chris Steel et all - that is the best book I have seen for Java security.

The title is, definitely, misleading: it does not cover the subject of J2EE security. One cannot build a secure application with this book! There are lots of great books on the Standard Edition security, and there is no need to go over it again, particularly when J2EE presents so many new issues and problems one needs to take care in order to build a commercial application. Otherwise the book is easy to read and understand.