5 comments about XML Pocket Reference.

1. The majority of the new material in this book is on different schema specifications. Schema, Relax NG and Schematron are covered. A handy book to have around when you are hacking XML. The online free documentation is not as handy as the content as it's organized in this book.



2. The other review book I received yesterday was XML Pocket Reference (3rd Edition) by Simon St. Laurent and Michael Fitzgerald. Depending on what you're looking for, this may or may not the book for you...
   
   Contents: Introduction; XML Structures; Document Type Definitions; W3C XML Schema; RELAX NG; Schematron; XML Specifications; Index
   
   Admittedly, trying to cover "XML" in a single book is a daunting task. XML is made up of so many standards and technologies (XPath, XForms, XML Schema, etc.) that you either have to specialize your coverage area or be ready to publish a *really* heavy book. To their credit, the authors stripped out XSLT into it's own pocket guide. That act keeps this particular book small enough to fit in your pocket and that's good. But if you're wanting information on XSLT and think this might be your book, forget it.
   
   Next, the XML Structures and Document Type Definition chapters seemed to be a little confusing. There was something introduced that I had never heard of before... something called "Productions" followed by syntax that looked like regular expression language. Never having seen that term before in my XML reading, I went back to the introduction to see what the authors wanted to convey there. The only explanation was "As each structure is discussed, applicable productions from the XML 1.0 and 1.1 specs will be listed in the order in which they appear in the specs." So, I still really don't know what productions are, and I probably have to go to the specs to find that out. The description of each section in an XML document, like CDATA or declarations, was nice though.
   
   The book starts to become really useful when you get into the XML Schema section. There they go into each of the elements along with each attribute that can be used with the element. This is the type of reference information I'd expect to see in a pocket guide. Something I can turn to quickly as a refresher for what parameters or attributes I can use with an element, or to gain a quick understanding of an element I haven't seen before. This same structure is followed for the RELAX NG and Schematron schema languages, so the book will be helpful if you live in those worlds also.
   
   Basically, I found the XML Pocket Guide to be a little "hit and miss". If the title had been "XML Schema Pocket Guide", I'd have felt like the book was pretty on target. Trying to call it the XML Pocket Guide seems to infer there's a lot more in here than there actually is, and a buyer might get a copy and be highly disappointed in what it doesn't cover. If you're looking for schema info, you'll love the book. If that's a secondary reason for you to get the book, you might be disappointed.



3. My problem with this book is that I was hoping it would concentrate more on just XML Schema, something I think most people would prefer. Of course, how I am qualified to make that kind of statement is beyond me ;-) But here is my reasoning: A fairly large portion of the book covers DTDs, RELAX NG, and Schematron. DTDs, while ubiquitous, are being supplanted by XML Schema. Usage of RELAX NG and Schematron are, by the book's own admission, not widespread. So it seems that all three of these technologies could have been admitted, as were many other XML-related technologies (XSLT, XPath, etc.)
   In addition, I feel the regular-expression-like inclusions should have been omitted. These include something referred to as Productions in one part of the book and Contents in another. Maybe good for hard-core CS people, but pretty much useless for those of us who just want to work with XML Schema. An ideal replacement would have been some examples illustrating sample usage of various elements and attributes.
   All in all, the descriptions accompanying the elements and attributes are pretty good. Unfortunately, that accounts for only about one-third of the book. But it only costs $10 and it is small, so maybe it's worth it.



4. I am one of the coauthors of this book. I feel compelled to write a review in support of my friend and coauthor, Simon St. Laurent, who wrote the section on XML Schema. Of the 160 pages of text in XML Pocket Reference, Third Edition, 71 pages are dedicated to XML Schema. That's 44 percent of the book. Of the 71 pages, 16 pages cover examples of XML Schema.
   
   DTDs are covered in 15 pages, RELAX NG in 32, and Schematron in 10 (57 pages total). XML Schema receives the most extensive treatment of any of the topics covered, and within the limitations of the size of the book, Simon did an excellent job.
   
   XSLT and XPath were not included in this book because a new, separate volume has been dedicated to those topics-XSLT 1.0 Pocket Reference, by Evan Lenz, which also appeared in August 2005.
   
   As for the production rules, they were included for programmers and others who need grammars. The productions, which come from the XML spec, are a means for understanding XML syntax precisely, and it would have been unwise, in my view, to omit them.



5. I bought this guide because I needed a quick lookup for XML schema elements (something you'd think would be readily available online, but isn't - at least not in a usable form). The bulk of the book (70 of its 162 pages - about half) is dedicated to XSD, so I was very happy with what I got. The first 30 pages cover XML itself (all the nitpicking details like predefined entities, what characters are allowed in attribute names, etc). The next 17 pages cover DTD (which you may occasionally still need to know, even these days). The next 70 cover XML Schema, and the book finishes up with an additional 43 pages on Relax-NG and Schematron (two competing, and not very common, schema definition formats).
   
   I agree with other reviewers that the book would have been complete without the Relax-NG and Schematron coverage, but it would have just been 43 pages shorter if that was the case - there's really not much else they could have said about XML, DTD and XSD and still have been a concise "pocket reference". This book is actually pretty thick for an O'Reilly pocket reference - I have four other pocket guides on my bookshelf right now, and the other three have 120, 124 and 66 pages each. By that standard, I figure the coverage of Relax-NG and Schematron were just a "buy one get one free" type of add-on, especially since this book costs the same as all the other pocket reference books.
   
   This book is a perfect reference for somebody who needs a quick, handy reference to XML schema and the occasional XML rule.

No comments about An Introduction to Mathematical Cryptography (Undergraduate Texts in Mathematics).

5 comments about Visual C# 2005: A Developer's Notebook.

1. I just borrowed this book from the library as I'm trying to cut down and only buy true reference books. I didn't have a whole lot of expectations, but this book was exactly what the doctor ordered. I knew C# for VS.NET 1.1 and am gradually migrating to 2.0 and all of it's extra features. I just wanted a book that covered the new stuff... and could come as close to just injecting the information into my brain without all of the extra fluff. This book does exactly that. If you're new to .NET don't get this book... but if you're looking for an incremental upgrade book (as I was) that is concise, full of examples, and covers the whole spectrum of VS.NET 2.0 then this is IT! That said, the title is just a bit misleading... the first chapter is about the new C# keywords and constructs, but this book covers changes with Forms, ASP.NET (Themes, Master Pages, ...) and so forth. This books has been hard to put down and I'm seriously considering buying this one to add to my reference collection. I've learned a lot from it in just the past 24 hours.



2. This is a very good "delta" book for moving to 2.0. It doesn't spend a lot of time with "object oriented programming began in 19..."-type gibberish. Instead it moves directly to some of the new features and talks to you like you know what your talking about.
   
   Easy read.
   
   However, the introduction says something to the effect of "this series skips the 'hello world' applications and is instead the often frantic scribblings of real developers performing real tasks" or something like that. In reality, none of the examples was terribly realistic. It was the same type of examples and 'hello world' demonstrations you would find in any other book. And the "scribblings" in the margins were often just pullouts from the text--just like any other book.
   
   Overall - good book. But the marketing hype for the series is just that--hype.



3. I purchased this book to get prepped for 2.0 development. As usual , Jesse delivered with additional benifits. He is a great, clear speaking, author. I needed the facts and he delivered.
   
   Well worth owning for those of you transitioning from 1.1 to 2.0.



4. I've had this book for almost two years now, and I consider it (along with Liberty's classic "Programming C#" [I have both first and second editions]) one of the most useful books for helping me move from "beginner level" C# to "journeyman" mastery of what has become my favorite language and daily working tool of choice.
   
   Liberty's books join with my books by Sells, Petzold, Gunnerson, Archer on that small shelf ... within arms reach ... which I consider essential tools to have as I work in Visual Studio.
   
   What I find unique about "A Developer's Notebook" is :
   
   1. Content : the sheer amount of immediately useful information and code samples. This is a book, imho, for people who've already reached initial mastery of .NET, and are ready for intermediate-advanced topics. There's more technical content, more information, "per square page" in this book than in many books on .NET and C# that are 800+ page "whoppers" :) And I do have the sense that every bit of code in this book has been "refined" to the efficient minimum without losing its "educational punch."
   
   2. Book Design : imho the design and structure of the book are a "tour de force" of technical book design : it's in the form ... almost ... of a laboratory workbook; the "asides," or comments, in italic script font in the margin of the pages add a very useful commentary that evokes and provokes thought.
   
   3. Immediacy : I get the feeling that Jesse is right there talking to me as he takes me through the intricacies of IEnumerable, Generic Interfaces, Delegate Covariance. Very good terse introductions to technologies like ClickOnce.
   
   4. Technical Format : the book has a format of presenting a concept concisely, outlining the structure of the classes or methods involved, describing a practical usage scenario, and then, in a section titled "How Can I Do That ?," presenting a key code example that demonstrates the technique in use. I find this similar to what I perceive as the "experimental" method in Petzold's books, and, for me, this is a compelling way to learn.
   
   4. Writing Style : As in JL's other books, I personally experience him as one of the clearest writers of technical expository prose I have ever read. In sections typically titled "What About," or "How Can I Learn More," for each major topic, he succinctly addresses questions that imho any intelligent developer might be asking about the limits or side-effects ... or the "gotchas" ... of the techniques presented.
   
   I like to compare learning a programming language with learning a musical instrument. It seems to me that initial mastery of C#, like learning to play the guitar, involves a required period of just learning the general way you use the tools (the Visual Studio environment, the .NET compiler, assemblies, WinForms, Classes, Interfaces, UserControls) : until you have that initial "vocabulary," imho, you can't really "play a tune." But once you do have the initial comfort level and mastery of the tools, you are ready to start with studying simple "Etudes" which are designed to be musically satisfying in themeselves and, at the same time, help you progress in mastery. Using that analogy, I consider "A Developer's Notebook" a book of "Etudes," an excellent one !
   
   In summary : this is one of the best technical books I've ever read. I do hope that at some point JL will do another book in this format, and structure, probing, in the same "experimental method" other topics in .NET 3.0 and 3.5 like LINQ, sophisticated uses of AppDomains and Contexts, the ability in WPF to get WinForms controls across domains, etc.
   
   best, Bill Woodruff
   dotScience



5. 
   This book is a quick way to get up to speed on C# 2.0. Highly recommended for developers new to 2.0. My only complaint is that it neglected to mention the new SqlBulkCopy class, an important addition to ADO.Net.

5 comments about Customizing the Microsoft .NET Framework Common Language Runtime.

1. If you want to understand the intracies of how the 2.0 build of the CLR has been designed and implemented to support the hosting of it this book is it. I am a very curious person, I love technology and even more I love to understand how it works...
   
   When I wanted a better understanding of how SQL Server Hosted the CLR than what BOL could give me I began searching. I was referred to this book by Microsoft Program Manager(s) (as in plural) and sure enough the book filled my void. If you are an expert Microsoft developer/architect this book had better be on your bookshelf.



2. After reading the positive reviews on this book, I hoped this book would tell me things MSDN did not. How wrong I was. There is more information on MSDN than can be found in this book. For example, in Chapter 1, the author lists the function ExecuteInDomain, referring to Chapter 7 for details. In Chapter 7, the ExecuteInDomain function is not even mentioned. Also, the author often leaves out crucial details that would allow you to actually understand the point he is trying to make.



3. This book does provide a great deal of valuable information for any .NET developer and is definitely a book worth reading. However, since the topic is a bit advance, it would certainly help if the example application used to illustrate extensible application architecture was more complete. The proposed example application 'Boat Race' started in chapter 5 provided a great beginning, but left the reader hanging even after reading chapter 6. The downloaded companion samples did not include any code sample for 'Boat Race', which was the main example used to explain the concept.



4. The topics covered by this book are so specialized that the vast majority of .Net programmers will have no need for this level of detail on these topics. However, if your application does require expertise on any of the topics covered in this book (I needed information on AppDomains), this book is excellent. It is very detailed, clearly presented and authoritative.



5. The book gives a good insight in the workings of the CLR as an unmanaged process.
   Require more full working code samples as against the code snippets.

5 comments about Querying XML, : XQuery, XPath, and SQL/XML in context (The Morgan Kaufmann Series in Data Management Systems) (The Morgan Kaufmann Series in Data Management Systems).

1. I've been an XQuery developer for an academic press for a number of years, and I read this book cover to cover. It sets out to describe methods for querying and does so,
   in an almost scholarly fashion, for many common but different contexts. I found it provided cohesion to the diverse world of XML, from broad subjects to the details of spec grammars--a very welcome contribution to a technical library.



2. My only complaint with this book is that it emphasizes DTD over Schema a bit too much. For this and other reasons, I felt the treatment of XML seemed a little dated, and also a bit shallow.



3. The authors are XQuery standardization committee members with long tenures at Oracle, thus possessing an unique grounding in that 'other' query language, SQL. As a result, the book is balanced with respect to what SQL/XML and XQuery can respectively do. A number of examples are provided, to illustrate where XQuery is useful and where other query mechanisms might work.



4. If you need to learn XQuery or XPath fast, this is not the book, or you need to skip the first 8 chapters. XQuery and XPath are hardly even mentioned until Chapter 9. The first 8 chapters discuss everything except what is in the title. XML is a pretty boring topic, and excess verbage doesn't help.



5. I have had this book for almost a month now. This book is painful to get through. I can usually get through a technical book within a week and try some examples. I started reading this book front to back and did not skip any sections.
   
   I am not a NOOB when it comes to XML so I found this surprising. I am a certified XML developer (from before XQuery), an experienced programming engineer of 8 years, an MCAD.Net, and I have even written a paper on XQuery for a Master's Program and I simply have become unmotivated and am struggling to get through this book. As others have stated in reviews, this book takes a long time to get to the point. I like to get my money's worth when I buy a book though.
   
   I kept asking myself chapter after chapter "when do we start programming some examples?" The first 10 chapters are filled with everything but XQuery. The author covers the background of XML and why we would use XQuery in detail. I see the argument for why this book may be beneficial to some but if you wish to get up and running on XQuery this is not the book for you.
   
   I may update this as I finish off the book. I am getting more into actual XQuery syntax and grammar as of chapter 11. A flip through the TOC shows that the author covers some implementation info. My goal was to have a better understanding of how to actually implement XQuery and learn some of the more detailed points of it versus just FLWOR that the numerous online tutorials offer. I have purchased another book by O'Reilly instead.
   
   Update: I received the O'Reilly book right after writing this review. I flipped through the TOC and first few pages of XQuery by O'Reilly for a comparison. Wow! These two books could not be any different. I am on chapter 5 of the O'Reilly XQuery book just in a few hours of off and on reading at work. It appears thus far to be the better choice. Luckily, work is paying for these books so I was only cheated out of time buying "Querying XML".

2 comments about Java 5 Illuminated: An Active Learning Approach (Book & CD-ROM).

1. The book is an excellent introduction to Java 5. This book does a very good job at teaching Object-Oriented Programming in an easy to understand progressive manner. All examples in this book are very instructional, and yes, the examples do compile. Kudos to the authors, Herve and Julie.
   
   As an experienced Java programmer, I found this Java resource very useful in emphasizing my software engineeering practices and helping me to focus on designing and writing correct, maintainable java programs.
   
   Chapter 4 detailing Applets and Graphics was very informative for me detailing methods for creating graphical output and drawing shapes and text.
   
   In Summary, this resource is a must have for any Java Engineer's technical library.



2. The school I've been teaching CS I and CS II at for the last five years used this text for both classes recently. Some members of my department criticized it (fairly, I think) for being somewhat weak on OOP (user-defined classes don't come until Chapter 7 and even after that their use is not pervasive in the examples) and deficient in OOD. We were therefore switched to another text. I now find myself sorely missing the strengths of Java 5 Illuminated: the exercises. Each chapter has a _ton_ of exercies, many of the drill type (what's the output of this, what line completes that, etc) that are tedious to construct but that weaker students need in order to build confidence with syntax. The authors write most of the exercises without referring back to the examples they've used earlier in the chapter, which is a big plus for me since I usually write my own examples. Each chapter is written clearly if a bit simplistically. Until I find what I consider to be a 5-star text I would be happy to use Java 5 Illuminated again since the missing pieces in it are easier for me to make up for than the missing pieces in other texts.

5 comments about Enterprise JMS Programming.

1. Excellent book covering so many practical issues for JMS systems. The architectural insights were certainly useful for someone new to JMS.

   The only complaint I have is the title - this books covers so much more than just Programming issues!

   Well done Shaun.




2. This book gave me real world examples, concepts and gotchas related to JMS. I found it very useful for understanding how to implement JMS with my J2EE application. It explained JMS in a fluid style that was easy to read.

   This book goes beyond theory and explains how to use JMS in different situations.




3. I bought this as I needed a JMS reference that went beyond the spec and talked about design, deployment and management of JMS infrastructure. I was very impressed with everything I read until I dipped into Chapter 13 - specifically the four pages on improving client-side throughput through internal queueing. While this is an excellent idea, the example shows how to build a complicated and threading-heavy internal queue and dispatching mechanism and recommends that you use it to, er, put events onto the Swing event dispatcher's internal queue. Hmm.

   The book (commendably) sets out to give a full picture of how to design, build, deploy, secure, and manage a JMS-based messaging architecture. This means, however, that it's very noticeable when a topic is skimmed over. For example, the section on bridging two different vendors' JMS implementations has two pages of simple code and less than one page of discussion that fails to consider administration, security, or performance, despite the normally good coverage of these areas elsewhere.

   Nevertheless, I was mostly impressed with this book - it's just a pity that the high standards it sets itself aren't met consistently throughout the book. A second edition that discussed the example architectures in Part III in detail would be a truly excellent book, and would be relevant to all messaging products rather than just JMS.




4. I have used JMS for about 2.5 years before I bought this book.
   There wasn't many books writing about JMS the first time I used JMS back in 2000.
   This book has a solid coverage of JMS and give you advice in designing an enterprise application using JMS.
   You can find samples of administration tasks for JMS Product from BEA Weblogic and iPlanet Message Queue.
   The only thing that I missed is the coverage of IBM MQ, which is the messaging infrastructure that I use.

   If you want to get a good understanding on designing JMS application, don't look further, buy this book, you won't regret your investment




5. First of all, I had high hopes for this book, based on other comments. I can only imagine comments were done by inexperienced people who didn't know too much about actual details regarding low-level details, or didn't mind factual errors, preaching style and skimming of actual useful pieces (beyond simple code examples one can easily get from Sun's JMS tutorial page).
   
   At first book seemed ok; first few chapters had proper introduction to JMS, at surface level. Too bad it never really got beyond the surface: usually author just listed things at high level ("you can do this and that for security") without even trying to get into concrete facts. Worse, when he did, much of the time "facts" were just plain wrong. Comments on UDP, for example, were utter gibberish, as anyone who has basic knowledge of IP networking protocols knows (even the acronym given was wrong). And this continued throughout the book.
   
   Writing style was also too preachy for me: most of "naturally"s and "obviously"s could (and should) have been left out; especially as often it's debatable if the statement following was even true. Check "performance tuning" tips for a good example on misguided tips that most experienced java developers nowadays would consider obsolete (for example, suggestions on aggressive object pooling and reusing, using final keyword).
   
   The final problem that I saw was that there were also a few typos (and/or cut'n paste errors): for example, in message definitions descriptions for fields were clearly cut'n pasted, as the stock quote message descriptions wouldn't otherwise make any sense.
   
   The reason for two stars is due to the fact that the code samples were usually ok still, and there were some useful tidbits from related subjects (like JCE samples).

No comments about Beginning Mac OS X Tiger Dashboard Widget Development.

2 comments about Sams Teach Yourself MySQL in 10 Minutes (Sams Teach Yourself).

1. I have read only half this book (the first half which is dedicated to beginners database work) and found it easy to read and useful. When I become advanced enough I will read the second half. It includes topics like the SQL off-limits words that you shouldn't use in your database naming fields - which is always helpful (Especially when you are like "I know this function should be working!" and it isn't because you've used something in that list - you won't spend hours trying to debug your code!)
   
   I will buy Sams Teach yourself books for other topics again.



2. This book is based on MySQL 4.0 and some commands don't work on the new version. And this book also has lots of errors. For example, some code (products table)of the sampdb is missing in Appendix B. And it also misses some details so that you have to solve them by yourself.Interesting though.

No comments about C++ Programming: From Problem Analysis to Program Design.