Customer Reviews

Professional Java XML Programming with servlets and JSP

5 star:		(7)
4 star:		(3)
3 star:		(3)
2 star:		(8)
1 star:		(9)

 

 

here is the kind of book one should not buy... Without repeating what other reviewers have already added (i wish i had read them earlier), i will add more to it. well, the title says that the book is on XML using Servlets and JSP. in first quarter of the book, there is no sign of either JSP or XML. As you go through the initial chapters, you get a feeling as if the authors are in love with some framework that they have designed, and this book is a users manual (or, programmers manual, if you prefer) to the framework.... now who on this planet will want to use such handi-crafted frameworks for professional development. So, as you could make out, the book disappoints you thoroughly if you are an experienced developer. but the worst thing about the book is that it will be equally disappointing for the beginners either. it doesnt explain any concept properly, doesnt give any explanatory, self-containing examples. each example refers to the authors' framework in some way, so none of them is self-explanatory... what else to say... i guess this is enough....

The most serious problem with this book stems from the discussion of medium sized applications built upon utilities that are slowly developed throughout the book. This essentially forces readers to pay close attention to the implementation of the author's framework and utilities (which may or may not be applicable to a particular reader). It also forces readers to read the book from start to finish with a minimum of jumping around.

Another problem with this book is that like all Wrox books, it is written from "programmer to programmer", and programmers in general are terrible writers. The authors of this book are better than most of the other Wrox programmers attempting to write books, but they still manage to come up with some pretty hideous writing, such as the following from page 44:

"We say about value objects that they can get bound into, and unbounded from, a session."

Excuse me? How about: "Objects can be stored in a session."

I also can't help but feel that the authors were not so much interested in educating readers, as they were in showing off their enterprise development prowess. For example, on page 56, we find this curious sentence:

"On occasion, when DBHandler uses one of our utilities that we are particularly proud of, we make a detour to present the utility."

It seems to me that the decision to make "a detour" should be based upon what best illustrates concepts at hand, not what the authors are "particularly proud of".

On the positive side, this book does provide a good overview of XML and enterprise Java technologies. The downside is that because of its structure, this book makes you work extra hard to find out the information that you really need.

I was very dissapointed in this book. It is all over the map and very shallow. This book has over 200 pages of appendicies which reprint, among other things, the XML spec!

It looks like the authors just wanted a big fat book with lots of buzzwords on the cover. Do they really expect to adequately cover Servlets, JDBC 2.0, JSP 1.0, XMl 1.0, Namespaces, XSLT 1.0, XHTML 1.0 in the 500 pages that are left? I hope not, because they didn't. Save your money.

Ok, now that I got your attention :) People blasted this book because it is hard to read and the authors are clearly very proud of their work. On both accounts, nothing is really wrong.

My take on this book is this: This book has A LOT of good ideas in it. This is how you survive and be competitive in the Internet world: Collect Good Ideas. One caveat, You have to MINE them, don't expect them to be served on a silver platter. Read the book cover to cover, that's why they invented books in the first place.

The book is about exploring ways to use XML, I was investigating this very subject and this book takes me through the authors mind into why and how they end up building their framework. To me, that's a very useful mental exercise as I come up with my own ideas for implementing design framework.

As a bonus, they also talks about things to consider about Middle tier functionalities such as DB Connection pooling, Meta languages, and XSLT (Watch out for this one!).

Final word, this book is worth the price. To the author, thanks for sharing.

I think the author does not need to go into parsing and EBNF to explain a simple idea as XML. There are too many chapters wasted on irrelevant material and a lengthy appendix. The book lacks a good chapter on XML and DTDs. I found the one XML chapter in the Java Server Programming book more useful than this entire book.

This book disappointed me so much, i thought that i will get the best of it when it comes to Java, XML, and JSP with database. On the other hand, the authours spent so much pages talking about things that are not worthy and only theories. No depth on any of the covered subjects. I agree with the reviewers who said that it makes the reader work hard. i had to pass through many chapters just to get a simple implementation idea. Too wordy for nothing.

I am a professional programmer with a background in C++ Windows programming who started learning JAVA a year ago. I bought this book with the intention of learning how to leverage XML in JAVA apps and servlets. I made it through the first chapter just fine and then all heck broke loose. I could not get the examples to work, the text became as clear as mud and I had to put the book down in disgust because every other chapter in the book lynchpins on knowledge from the previous one. This would not be a good buy in my humble opinion.

I think this isn't a very good obok. First, it's not written in a very clear way, I simply didn't understand everything in the book. However, the biggest reason not to buy this book, YOU HAVE TO READ ALL/MOST OF THE CHAPTERS TO UNDERSTAND PARTS. Why is that bad? Many people, including me, like to read only relevant chapters. For example, if you already know some of the stuff, you skip directly to the right chapter and read from there. You can't really do it here, since the authors create lots of classes they constantly use in later chapters. Thus, it makes the book terribly inconvenient. Maybe this is only my impression, I didn't read all of the book, but after a few chapters that I found myself reading stuff I *DIDN'T WANT TO READ*, I just abandoned this book and moved to another one.

The book contains a lot of useful information but since everything is very interconnected you can't really read just the parts that are of interest to you. Getting the environment set up to run their examples is also horribly difficult. I'm a fairly knowledgable server-side Java programmer yet I was unable to get their example systems configured and working after several wasted hours of tinkering. Better setup documentation is crucial.

This book appeared to be started with the intention of being a primer on Framework development. (For example there are references to a chapter on UML and Patterns that never appeared).

The usefullness of this book is highly dependant on the role you wish to play in your future projects. If you are trying to get your first gig as a Java developer get another book.

If you are a fairly seasoned developer and want to move into an architecture role, this book is a fairly good example of the forces which drive modern application development.It also provides insight into how software architects design systems and frameworks to address the set of conflicting forces which come into play. I found the book to be an interesting case study