Markup Languages Books

I am new to the field of web and databases and found this to be an excellent book. It is very well written and very easy to read. It does not hype up the area like some other books do and provides a very realistic picture. I am now eager to learn more about the field.

This books covers a lot of topics very well. It starts with a discussion of web databases and semi-structured databases and then goes on to discuss XML, RDF and finally ties all the concepts together in a discussion of the semantic web. Semantic web is still evolving and the author clairifies the various concepts quite well. While this may not be at the right level for a technologist or a developer, this book will be quite appropriate for a manager or executive who wants to get a quick introduction to the semantic web and XML.

The author provides broad overview of the semantic web and XML. It gives a beginner some insights into the field. It does not go into depth on XML, but gives several references for the reader to find more information. It also takes a database perspective in discussing the semantic web rather than an artificial intelligence perspective. I find this aspect very interesting.

This books covers a lot of topics very well. It starts with a discussion of web databases and semi-structured databases and then goes on to discuss XML, RDF and finally ties all the concepts together in a discussion of the semantic web. Semantic web is still evolving and the author clairifies the various concepts quite well. While this may not be at the right level for a technologist or a developer, this book will be quite appropriate for a manager or executive who wants to get q quick introduction to the semantic web and XML.

If you know anything at all about XML and the semantic web - DO NOT WASTE YOUR MONEY ON THIS BOOK. This book covers nothing in depth. I just spent 3 nights reading this book - waiting for something to happen - it never does. The author does not go into any decent technical detail on anything. If you have ever worked with XML and want to learn something about RDF etc... this is not the book for you.

This book is awful. Save your money.

Great place to start CSS and dHTML or refresh your memory plus a handy reference. This book tells you exactly how to create the nice little dHTML menus that you see at places like eddiebauer.com and others. Missing a few things. For you beginners, this does not directly cover the difference in Class vs. ID in the div tag but more hints at it. You're supposed to take what he's doing as gospel. Might be missing a few of the cool tricks from dHTML but overall it's great.

I found this book quite dissapointing. I thought from what I read in the book summary that it would be a book on more advanced techniques, but it was really quite basic. Not a good beginning point for learners, and too basic for people who know more than the basics. Also, about 40% of the book is made up of reference appendices, disappointing, since the book isn't all that long (7 chapters, only 3-4 of which actually address real DHMTL). I would not have purchased this book if I knew before hand what I know now.

The author uses browser version sniffing to achieve cross-browser DHTML, which means your code WILL break in the future if you follow his advice. Object detection is the way to go. I'm angry about the way this joker discusses CSS2 positioning properties such as float, clear, and position. He simply says, "These aren't supported the same way in all browsers, so just avoid them for now." I guess he has no faith in his own flawed cross-browser techniques! Hah! There are a couple good examples for beginners on how to hide and animate menus, but they are all heavily based on his terrible cross-browser javascript code. Finally, this book is very short. To make things worse, the pages are small, and the font-size is big. I recommend the 1400 page "Dynamic HTML - The Definitive Reference" second edition by Danny Goodman.

This may sound harsh, but if you can't learn the basics (and more) of DHTML and stylesheets from this book, then you should probably not be developing web sites. I've been slogged through hundreds of computer books throughout the years, and this is definitely in the top 5 as far as quality of writing, timeliness, usable code, and emphasis on real-world application. The text and code for the stylesheets (that's CSS for newbies) along is worth the price of the book. This book earns every one of its five stars.

Being a beginner at Latex I began reading with the thought
that the learning curve would be a long one. I soon found
myself writing a few simple document as soon as I read the
first 3 chapters... on the day I purchased the book. I'd say
it definately clarified a somewhat complex programming
concept for me.

This book is a very poorly written book, trying desperately to introduce you to the LaTeX world. The examples it has are detached, the whole script way of writting is not clear, it isn't fully explanatory trying to light touch all the subjects does a not so clear job. I am using LaTeX for years and I had some hard time navigating myself through the thick structure of irrelevant junk this book has. Please if you consider buying this book, you can aswell consider downloading the LaTeX instruction manual for free from the Web. The former will be a waste of money, the latter will be a non-time consuming investment!

This is still the best introductory text for LaTeX that I've seen. The Linux Journal review got it exactly right -- this book takes the the mystery and complexity out of LaTex while still tackling many advanced aspects of the language. It uses good examples and is actually formatted using LaTeX. As such it provides a strong visual argument for the power of LaTeX and the value of learning it. This is a great book for doing exactly that.

... users with some experience with this package will find it next to impossible to use as a reference. Bits and pieces on a topic are often scattered throughout the book. This works if you read it from beginning to end as it builds up in sophistication. On the other hand, it makes it difficult to find answers when you need to look something up. The book description is entirely accurate: an "introduction and guide to using LaTeX". The book also has some coverage of the various utilities one needs to make effective use of LaTeX (it would have saved me some time if I had it when I got started). The physical layout of the book may come as a bit of a shock (it initally struck me as uneven and unprofessional), but now that I look at it a few years later I realize this was largely due to the fact that there are a lot of examples of the output produced by the various examples (the whole point is to show you how to do things instead of selecting examples that won't interfere with the look and feel of the layout). The negative reviews this book has received are unfair since they were written by people who wanted an advanced book and bought this one ignoring its description (it quite simply isn't reasonable to say that Hondas are useless just because you're in the market for an exotic sports car). Those looking for more advanced books should consider the three "LaTeX Companion" books by Goosens and friends (these books are suitable for use as reference). The truly advanced user should have a look at "TeX Unbound" (not specific to LaTeX, but extremely useful once you are capable of reading and absorbing its contents). For the novice, I would recommend the Lamport book in addition to this one: it is thin, easy to carry around, and does a fantastic job presenting concepts (doesn't cover nearly as much ground as this book, but does a much, much better job at what it does cover).

I agree with the last two reviewers that Latex for Linux is an excellent teaching book, with simple explanations and lots of examples. The explanations may be simple but the material explained isn't---NFSS is usually considered advanced. Here, it was tucked in where it logically belonged. And made understandable.

I didn't find the typesetting ugly. I have a copy of the 2nd printing, so maybe they improved the print quality--it looks fine to me.

Paul Jackson's review wasn't very relevant. He didn't seem to have gotten far enough into the book to know the author was a her not a him. When I'm learning a new environment, I'm looking for a good, clear tutorial not a "good read" This book is a very good tutorial.

This book is helpful for programmers have understood XML and Java(Servlet or EJB) . Because I don't understand XML, I only use this book as "Examples for XML and Java".

In my 17 years of buying and reading software development books, this work rates among the best I've ever seen: its clearly written, easy to read, packed with all sorts of helpful context and detail, and conveys the enthusiasm the authors have for their subject matter. (Also the size is reasonable and its not padded with whitespace and screen-shot filler so common these days...)

This book is surely helpful for programmers have understood XML and Java(Servlet or EJB) . But it is imcomplete to explain the relationship Java and XML. So I only use this book as "Examples for XML and Java".

XML Development with Java 2 is not quite as solid a work as it might appear from first glance. The examples, though thorough in their coverage, are incomplete in several respects. To explain: one of the first code samples in section 2.17, is not included on the CD Rom source (how many others are missing?); the book fails to mention which of several third party Java libraries are needed to build the sample applications, and much of the required software is not on the CD Rom so once you identify the libraries you must find, download, and install each one from the internet; the Java 2 compiler complains of deprecated apis; compiling chapter 8 sample code results in complaints that classes cannot be found - listing 8.6 calls for sams.chp7.XMLUtil, which doesn't exist.

Having complained to the technical support link at the back of the book, the only response was that they appreciated the comments and would consider what would need to be done for the next edition of the book.

Overall, I am impressed with the content but am non-plussed by the level of quality and technical support. If you want a book that you don't have to second guess, this book may not be for you.

I don't like this book for following reasons:

- The source code can't be used on a project due to bugs and poor quality.

- The author does not know what Java Beans are but goes on to provide a buggy utility class.

- About 30% of the book is dedicated to non XML related concepts such as EJBs and Servelts etc.,

- Does not explain the concepts of DOM L1/L2 in detail.

- Does not describe JAXP in sufficient detail.

There are few more reasons, but I will stop here due to lack of time...

The landscape of Java & XML is very dynamic. There are lots of good books on XML but there are no good ones that provide good conent in the context of Java and JAXP. There is no point in buying this book unless company is paying for it.

I'm reading Michel Kay many years ago. The XPath separate book from XSLT book is a very useful tool.

If you are an expert in XPath then this book might be worth having. But if you only have a general knowledge of XPath this book is basically useless. The author clearly has a solid knowledge of his topic. But the ability to communicate it in a practical way is sorely lacking.

The problems people describe aren't the author's fault - I think. If someone did the ghostwriting, even with him dealing with the submitted manuscript, then shame on Mr. Kay, although his reputation would preclude this being a possibility. I think the odds would be like the lottery - so this would be an anti-lottery.

As to the quality of the WROX books, something many people forget is WROX went belly up, despite the quality of their material. The assets & IP were picked up by Wiley in 2003 (http://www.wrox.com/WileyCDA/Section/id-105072.html). Most news doesn't mention the financial straits, just the purchase.

When Windows 3.1 came out in 1992, many asked "What's the best book(s) to buy?" The general concensus was "Petzold (MS Press) and any of the following list...". As web development has become the hot topic of the previous seven or eight years, specifically with the maturing of Microsoft's IIS/ASP, evolving into .NET. O'Reilly has long been recognized in the *NIX market and has successfully branched into many other disciplines successfully. Enough so that it's considered to be on the list of "This [O'Reilly] book and any of the following...", which may or may not be an O'Reilly book, but it's not a surprised if it is. The familiar dense (weightwise), red book with author headshots (WROX) have a similiar standing with many developers, frequently expressed to be of good standing in recommendations to others.

Unless the critical personnel were transferred along with the purchase, then the relationship between Wiley (the new owner) and WROX authors at the hands-on level and the ability for the Wiley people to acclimate and maintain the habits, philosophies, and perspective of the WROX "style", then there will be misfires, such as we've seen in the two new Kay books.

Good authors are flexible but when it comes to computer books, the various types of editors have the ability to considerably alter the destiny of the content. This can be in terms of pre-submitted direction or changes made inhouse. On top of that, unless things have changed radically in the previous years, books are written on accelerated scheduled, edited, returned to the author for verification and only [hopefully] minor changes in response to queries from the various editors. Once that manuscript is at the publisher, it's tough for external forces to change what will likely happen to the book. Aside from software feature changes (e.g. in beta), the direction has been established and things move forward.

One would hope as X* continues to mature there will be another opportunity for the second edition of this book to overcome a first edition which should have been a complement to Kay's XSLT Programmer's Reference, a must-have item on the shelf of anyone who claims to work with XSLT. Important enough, as I've said elsewhere, it's an interview question: what XSLT books do you have on your shelf? If Kay is missing...then either the candidate is *so* good they don't need it (extremely rare) or their unfamiliar enough with what's going on in the real world (and real world resources) they are likely not to be at a level they should be and may need to be nudged into additional professional growth with the book.

Rating? ** As Clint Eastwood says in The Gauntlet, "I'll give her a two. But that's only because I've never seen a one." In this case, we've seen a 4 1/2 or 5 star XSLT book unable to transfer its performance to an equally important sibling. The potential is there, the content is [mostly] there, the author is there, so it's better than nothing, or a lesser work from someone less qualified than Mr. Kay. Because we've seen an extremely high quality product, we have to look at this with an critical & hesitant eye.

For those who feel they've been punk'd, particularly if they've had the book strongly recommended to them, more's the pity. They're at a fork in the road, requiring a coin toss: keep the book for what's there or return it to the publisher with a few specific statements regarding your displeasure and what you expect. Otherwise, you're probably going to be presented with a choice of another WROX book (or a book from another publishing house within the Wily lineup). If you want your money back, you're going to have to be firm about that. Money going back out is money out of their pocket(s). Keeping a customer happy, as opposed to pacifying soon to be ex-customer, regardless of what else is said or done is far less expensive and they feel it's a generous sign of good will.

I have never had a question about XPath that wasn't answered by this book. I appreciate having an authoritative reference written by someone who was deeply involved in the development of the standard.

However, this book (and its companion XSLT reference) is perhaps the worst-formatted reference book I have ever seen. Much of the book consists of an alphabetical reference of XPath functions. Unfortunately, the page headers and footers only contain page numbers and chapter titles. They do not contain the name of the function that is described on that page. So you can't just riff through the pages watching for your function to appear in the footer.

There is a heading for each function name, but the font used for the sub-headings are as large as (if not larger than) the major headings. There are no page breaks between functions. So you can't even visually scan the pages looking for your functions.

Finally, the table of contents consists largely of function names on the left, with page numbers on the right, separated by about five inches. But there are no dot leaders between them. So, even when you resort to using the table of contents to find the section you need, you have to use a ruler to find the page number.

After stumbling around trying to a handle on XSLT, I finally realized that a big chunk was not being explained within the XSLT books. Most of the XSLT books bring XPath statements out of hat like a magician's rabbit -- there is no way one can figure out what to do in any given situation. Thanks to this book, what was mystery meat is now clear as a bell. In the first nine pages, a dozen questions were answered. I don't see how you can do serious XPath and XSLT without this book in hand.

The book explains, as other XML books do, the basics of XML. Discussion in this book is mainly focused on how to use SAX parser to read XML data and there is no discussion on DOM. The contents, specifically the examples in the book are not really helpful to "build" applications but understand how one might use a SAX parser to parse an XML document.

A good "101" book for someone trying to understand how to use Java and XML.

I recommend this book. It probably shouldn't be your first, or only book on XML though. For example, it doesn't go into much detail about designing/creating DTD's, or at least wasn't very clear in that aspect. However, for me, it served it's purpose well, to show me how to use XML, doing so using some small but practical problems.

I'm very satisfied.

In my opinion, the most important tools for building XML applications are DOM and XSLT. This book covers neither of them. It only covers SAX and CSS which are poor substitutes. While SAX has some advantages over DOM, it does not help with outputting new XML which is a common need.

I bought "Building XML Applications" expecting a ractical hands-on approach, a demonstration of XML capabilities by way of actual examples. And while I found the book to be, in general, technically useful, the book is weighed down by a writting style that is, at best, verbose and redundant. There is so much of this stylistic padding that it becomes rather tedious to get past the crud. I understand writers sometimes get paid by volume, but if you have nothing to say, say it! Overall, a good source book (as long as you don't try to actually read it).

I found the in depth review of the parsing tools available to the Java community extremely useful. With no previous knowledge of XML, I was able to incorporate XML parsing into my apps in under a week.

However, the book is weak on presenting styling information, particuarly in the area of XSL. I realize that this was and is a rapidly changing standard, but a basic background with examples would have been nice.

For the most part, industry standard RSS is a very short list of simple XML elements. Standard RSS Readers only look for those standardized tags to create the display. You can verify that by opening almost any public RSS XML document and just looking at it. RSS is simple enough that you could probably pick it up by just looking at a well formed sample file and reading the short syntax document provided for free by the creators (UserLand Software for RSS 2.0 or the RSS-DEV Working Group for RSS 1.0 - FeedValidator.org has links to the documentation). After reading this title, I am a little confused as to whom target audience is supposed to be.

The first issue I had with the book is the coverage of versions. The author has chosen to write not only about the two current versions (1.0 and 2.0 - two companies, two separate tracks of standardized tags), but the preceding versions for each. I don't buy a Word 2003 book to learn about Word 6. The layout could serve as a reference guide for the tags when you're done, but again, the vendor provided syntax guides are easier to reference. Next, the author makes some assumptions that aren't publicized; you should be really (really) familiar with XML to understand many chapters in the book, and you should also develop in Perl (as there are numerous, lengthy Perl scripts used as demos). I've created many RSS Feeds for both company Intranets as well as Internet sites, and given the simplicity of RSS, I can tell you that you don't need either to create a feed on your own.

The back cover claims the book is a "step-by-step guide to implementation", but it really isn't. The author has written a very nice book on the general history and specs of standardized RSS, but then fills the remaining pages with a general syntax overview of other commonly used RSS XML namespaces (not really demo-ing them), ideas for extending RSS with your own XML namespaces (which is great, but really just produces a customized XML document that industry standard RSS reader's won't know what to do with) , and then transforming other site's RSS Feeds into your own conglomerated XHTML page with various Perl conversion scripts, SOAP tie-ins, etc.

For the percentage of people that already know RSS and are looking to really go into advanced manipulations - this is a great title and I recommend it. For everyone else who just want to quickly learn the very simple syntax, this is a misleading title and I would recommend saving your money and reading the vendor's free syntax guides, or talking a quick on-line course. You'll find RSS easy enough without this book.

I must underscore the reason why I capitalized the word "PRINTED" in the title of this review. This is indeed the best book about the topic of RSS (RDF Site Summary), which has become increasingly more important since blogs jumped out of tech obscurity to become a mainstream form of web-enabled information dissemination. However, nowadays the topic is too dynamic (there's too much happening these days in the field of RSS) to make Hammersley's book a comprehensive and current enough resource for all matters and purposes.

As a general introductory reading, it's the best book out there. But once you get your feet deep enough in the RSS waters, you need to go online and search for the current APIs, Web Services, News Aggregators and RSS/Blog Directories, which is the area where the book will fall behind the fast growth of this area. Overall, very well structured, even with an appendix on the XML you need to know, in order to be able to deal with RSS.

I was expecting this book to show me somewhere in the first hundred pages an example of how to create an RSS feed. Instead I got wayyyy too much history, and I couldn't find a "hello, world" example.

I grant that the history is important, and this book will probably fit in well to the cadre of books that emerge on RSS over the next year or two. However, this year, this isn't the book I needed.

RSS is just XML in a certain format. At its core, it's pretty basic.

The author goes into MUCH detail about the history of the format as well as older (and nowdays rarely used) RSS versions.

It was interesting reading the history, and the details on the format and extentions was great. It really helped me get up to speed on RSS.

I would like to have seen more discussion about what RSS could do though. If I was consulting the author on the 2nd version, I'd have suggested dropping the info about older formats and putting some info in about the new uses of RSS...like iPodder, or the Presidential debate feeds.

If you want to get started quickly, this is a good way to jump in.

This book really is a must-have (or must-read-once) for anyone interested in RSS syndication technology.

It contains a lot of information on creating RSS feeds and related scripts. Most of the non-RSS code is in Perl, so if you don't use Perl, some of the book might not be handy.

I was disappointed that the book didn't cover much of the user's end of syndication... things like scraping and RSS readers themselves, but that's obviously another book.

This is a really nice title if you're interested in the techie side of RSS, but if you're an end user, there won't be too much here for you aside from the bits of history.

Out of date concepts, large print, tedious line-by-line code walkthroughs and a 200 page Appendix all conspire to make this book a waste of valued cash.

I bought this book with hopes of more discussion of how XML should be structured when integrated with CICS, or another Mainframe application. It seems to be totally a treatise on how Java should be coded: There are numerous examples of Java code, and would be helpful from that angle. I may find it helpful later when the bridges to mainframe data are understood by me.

I bought this book to learn more about enterprise application integration (I do systems integration consulting). Parts of the book were somewhat relevant, but by and large, this is an outdated Java and XML book. This book includes a primer on basic XML, and some introductory SAX and DOM examples, but at least a third of this book is useless filler like the XML spec from w3.org.

Buy O'Reilly's Java and XML by Brett Mclaughlin if you want to learn about XML and Java working together - he is the author of the JDOM API, and that book is much more up to date.

I'm still looking for a good Enterprise Application Integration/Middleware/data process book that explains best practices.

This is a serious book for java programmers, not for html writers. I found it excellent because: (1) It focuses on how to share data between different applications and servers, which is the topic a real world developer has to master. (2) It provides very good Java sample codes. After read this book, I finally understand how xml could transfer data in a B2B application.

But be careful, if one's background is webmaster or html author, She better picks a book on how to use xml for presenting contents. This is one for data sharing that can be used on B2B.

This is a good starter book for someone who is already familiar with java and is interested in learning simple integration techniques using XML. However, I have to agree with Annette Olson that this book is not for those who live and breathe integration and are looking for better, faster, more comprehensive integration solutions.

In my opinion this book provided far too much information on the basics of java and XML and not enough useful information about real world enterprise integration. The book claims to provided detailed information regarding integration into legacy applications, but after reading this book cover-to-cover, very little could be found on this subject

As for the "Top 500 Reviewer"(water_monkey) I would suggest that a more comprehensive educational regimen be implemented in order to bring yourself and your pupils up to snuff. Honestly, the java in this book was quite Ho-Hum. I skimmed over most of the first 7 chapters in search of the "heart" of the book. One would think that a professor would most certainly have a strong grasp on concepts relating to the relatively simple code provided by this book. I'm sorry to discover otherwise.

-john

java
xml
fun

I didn't know what HTML was before this book. Now I can write my own simple webpages. Excellent.

I have absolutely no knowledge of programming and was able to easily read the material and understand it. The graphics are also great. I would recommend this book to anyone.

I do recommend reading "HTML 4.01 Weekend Crash Course" if you already own it. The copy I bought and read is copyright 2000. The title might be changed to something like "HTML and related activities" as it covers considerably more than just HTML. That seems necessary to me. It would be a problem not presenting the other topics. This book does an admirable job of covering that amount of material in the 30 sessions meant to be read during a weekend. There are spots that are a little rough. It hints of being a first edition that would benefit from editing. I would wait for the next version, as there is some dated material that is only going to become more of a problem. Having said that I benefited from having read the book after having taken web design and web programming courses. I recommend reading this book (the new version) to prepare for such courses in order to take better advantage of them.

This book took me from knowing absolutely nothing about HTML to being able to create a basic web page. It was very clear about using text and basic graphics. The CD-ROM included the code covered in the book as well as .gifs and .jpgs to practice with. After completing this book I was able to move on to more advanced HTML as well as JavaScript with a good understanding of the basics. I would recommend this book to anybody who has no prior knowledge of HTML, although I would suggest they take a little more time than a weekend to learn it.

If you're looking to get up and running with HTML, and have no prior experience, this is a great book. You'll be introduced to the basics with an approach that gives you the confidence to learn web design. Topics are arranged in a sensible order, and the overall tone of the book is straightforward and won't fighten off a beginner by plunging headlong into a lot of jargon. This book is an excellent starting point for anyone interested in learning HTML.

First of all, it is out of date.
And, it is not enough for a developer to learn how to use XML in J2EE environment. Yes, it does have some sample code, but not enough.

The book covers a wide range of XML technologies and its implementations in Java. Most of the examples/patterns discussed in the book apply equally well or can be easily adapted for non-J2EE Java application.
Some examples use depreciated APIs, some use APIs that no longer exist in latest packages. It's not a big problem and equivalents usually can be easily found. Just be aware how fast the technologies are evolving.

Java and XML have a great synergy, they marry together to create a "Write once, run anywhere" with a "platform independent data" paradigm. The nice thing about this is that you can keep the service interface relatively stable (e.g. use XML document instead of a specific data structure). But often what people overlook is, if you choose not to expose/distribute your data model directly (using classic data structure/class), then you have to expose/distribute the meta data of the data model (in XML world, this is called schema). Once the schema is changed (as you change in the data structure/class), you are pretty much facing the same problem as in the classic data model, the communicating parties have to know what is changed and change (the parsing rule at least) accordingly. Particularly, in the internal system, the benefit of using XML interface is dramatically reduced.

The authors of book are trying to push every data model in the interface by using XML document, even the data persistence, along with various X-technologies. That is a very "dangerous mind" if not done carefully, since XML is not a panacea in design and development. Even in modeling data, XML is not one size fit all. So when is it a good idea to use XML for your data? The following is that I quoted from Ted Neward's blog,

When your data is naturally hierarchical to begin with
When exchange with foreign platforms (which is to say, platforms not native to what you're currently authoring in) is important
When pre-existing tool support (XSLT, XML viewers, import/export utilities, etc) is of paramount importance

As you can see, there are some constraints before you decide to go with XML. Not mentioning the performance overhead. Though authors mentioned that designers need to justify the usage of XML by various criteria, but this is a book about promoting XML. :) Don't be trapped.

Overall, the book contains some useful information about various XML related technologies, particularly the chapter 5 "User Interface Development" (which is quite funny for a server side development book). And the information is too general or shallow to be useful in the real world development, you need to dig more into the technology by yourself from this introduction.

There are some examples showing how the concept could be working in the real world. But they are very rudimentary. Some specs the authors used (e.g. JAX-RPC) are already upgraded or changed. As a book on such popular topics regarding J2EE and XML, it sets the bar too low.

This book gives you a very well-organized and informative tour of what's happening in the XML arena, the problem is this particular area of technology already so wide and so fast-expanding it's very difficult to get into the deep details of all areas, but the authors have done an excellent job of choosing the right technologies of tomorrow and delving into the details of those with sufficient background-story and code examples; in fact I would have given this book 5 stars if it didn't waste the first 40 so pages on explaining the client-server and peer-to-peer architectures and some extremely basic/boring J2EE and other generic topics, which has no place in a techy book like this. I would urge the reader to skip thru Ch. 1 in 4 minutes and dive right into the next ones, which are really very well written.

Beginners may use this book as an invaluable reference, intermediate level developers should only look into area of their interest, even advanced developers might find a few topics of their interest. Some of the topics the authors had to cover in a hurry, I'll say they have done a very good job in taking one specific feature and dissecting it, for example which discussing JSPs, the book lists a working example of JSP tag and explains it well, I'll say overall, the book is very well balanced between providing theoretical and background information on XML technologies and providing actual implementation examples. And yes, they did not miss out on the design patterns which are useful in this context!

Errata
page# 144: Boolean (instead of boolean) has been listed as a primitive type.

The title of this book tells the story, except that it should probably include the word "Overview". It is an easy read that provides solid information, but it is by no means a reference. It offers a nice, quick description of several aspects of Java and XML development, but I kept waiting for the meat. If you are new to XML in Java, this book will bring you up to speed on the APIs and uses of XML.

It starts with a review of J2EE architecture and XML development, which is helpful because the authors' perspective on these topics sets the stage for how they suggest using XML in a J2EE project. It covers the various XML-related Java APIs (JAXP, JAXM, etc.), and these are the parts that I found most useful. It also discusses some architectural options, which I expected to be quite helpful, but they needed more detail and discussion.