5 comments about Mastering Borland Delphi 2005 (Mastering).

1. I found the book attractive and easy-reading. Marco Cantu boosts Delphi learner's expectations again, with this Mastering Delphi 2005 edition. The author makes learning Delphi a gentle issue, as if he's chating with you personally. Definitely, the book is a better choice for learning Delphi.



2. This latest in Marco's Delphi series is a must-have for anyone who is serious about rapid Microsoft Windows systems development. In contrast to most, perhaps all, of the technical books dealing with creative development, this one is very readable, and more to the point immediately useful.
   
   The rich code samples are immediately applicable to today's right-now applications, with background material that is succinct and helpful.
   
   It's still applicable today for one simple reason: Delphi is still the fastest and most reliable way to build robust Windows applications, bar none. The economic impact of this simple fact is why Delphi is still being used today, despite Borland's self-induced problems, and will continue to be used for the same reason for as long as Win32 is around - probably a long, long time indeed.
   
   DISCLAIMER: Borland wanted to do a case study on my company's use of Delphi, even after I told them I thought that their marketing department was brain dead. They compiled and published the case study, but I still believe that their marketing department is brain dead.



3. Marco Cantu presents another fine in-depth Delphi book. I treat this as more of a reference rather than something you read start-finish. Its over 900 pages long and I recommend having tried Delphi for a while before picking this book up. The downloadable demos are especially helpful. Highly Recommend it.



4. The book covers the fundaments of the Delphi 2005 programming, in an inteligent and clear way. Doing more emphasis in win32 development but not leaving alone to .NET interested.
   This book mantain the expected quality for an author like Marco Cantu. An recommended choice for all Delphi developers.



5. For subscribers of the previous mastering Delphi series this book is not going to add much to your knowledge of Delphi.
   I have the Mastering Delphi 4-2005 and I haven't really opened this one as it offers nothing new.
   For the beginner in Delphi this would prove as useful as Mastering Delphi 4 was for me; invaluable.

5 comments about Memory as a Programming Concept in C and C++.

1. I agree with the other reviewers. In general this is good book. It bridges the gaps between many computer science disciplines. Especially OS and programming language. It also touched a little bit on computer architecture and linking process. The text was written in a a very clear way. However, I do have two complains. The author didn't spend enough effort on the relatively more complex and advanced topics. Eg, linking process for C++, advanced topics in memory leakage detection and prevention. On the other hand, author spent too much energy describing linked data structure in terms of serialization. I personally don't think its relevance is higher than the advanced memory leakage issues. For seasoned profressionals, this book can be used to refresh your knowledge. It is a beginner level to intermediate level book.



2. An older book that could be helpful to readers interested in this book is "Inside the C++ Object Model" by Stanley B. Lippman. It was written in 1996. It shows things such as the layout of C++'s organization of (pointers to) virtual and inherited methods.



3. as a C programmer for 3 years now i'm still learning and as you go along you realize how much C is really about memory. This book only served to reinforce that. the examples were great and even the example code he has in there, the only reason i gave it four stars is because the book wasn't bigger. I loved this book and gladly recommend this to any C programmer, budding or veteran.



4. First I would like to state the reason I gave it 4 stars. In my opinion, 5 stars should be very hard to reach. Maybe I would give this 4.5 stars if it was possible. Anyway, I'm a self taught VB 6 programmer with a working knowledge of the Windows API. First year CS student, though I've read many a book on C and a few on assembly. I have a large CS library and this is the first book of it's kind that I've found. It is a little pricey if you compare book size to other, larger CS books, but I don't think it is overpriced. The material is great, though I wouldn't say it is a beginner level book. I had trouble grasping enough of the material that it causes me to think either I've still got a long ways to go in learning (more so than I thought at least), or it is just not for the beginner.
   
   I would recommend this book to anyone who is serious about a programming career, regardless of the language. The book's relatively small size should not be a negative factor. It is not densely packed with information to the point where interpretation is needed, instead it explains in sufficient detail without dumbing it down by over-repetition and such used by some other CS books. It is aimed at C/C++ programmers, so being familiar with those is a prerequisite, obviously. Like another reviewer said, there seemed to be a little too much discussion on, say, serialization of linked data structures, an important topic with regards to memory yet I felt a little more emphasis could have been placed elsewhere.



5. I bought this book thinking I would get more insight about memory models in C and C++ languages. And how memory is a different resource. With its typed and untyped properties. With discussions about C++ RAII etc.
   I was very disappointed to find out that this book is actually an weak explanation of how compilers implement the object model.

4 comments about JasperReports: Reporting for Java Developers.

1. There is such a dearth of documentation on JasperReports. This is a very nice explanation on how to use it, there a good set of examples.



2. I was looking for complex examples on crosstab reports but found only basic examples. I wish they had a chapter on Dynamic reports and a section describing the jasper report object model.
   
   Otherwise it is a good introduction into Jasper Reports as it goes through all the features (rather than searching through the jasper report forum).



3. Heffelfinger's book meets all my tests for excellence in technical manuals. First, it addresses a development problem I am having today; and it is the only book on the market - including books and articles published by the vendor - that does so. Other favorable attributes include these: the book is less than 3/4ths of an inch thick, weighs less than a pound; cost less than $50 bucks; and there is more white space than dense text.
   
   Some authors of technical books must think we buy their books in order to better understand and appreciate their verbose writing styles. I did that sort of thing in my literature courses. When I am under the gun to produce bullet-proof code I want the insight and keyboard sequences that get me to user acceptance with the shortest time, and the least grief.
   
   Finally, maybe most important, the book is full of brief, readable, complete, and relevant code. When compiled, the code actually works on my ratty old development machine with a minimum number of obscure error messages. There are many references to needed downloads and sources of information relevant to the topics discussed. The error messages can be resolved with some careful re-reading and re-thinking. Thus do we get through our learning curves. Unlike some technical books, the error messages generated by the code in this one are not black holes where hours of time disappear without ever regurgitating a solution to the problem that caused the error.
   
   My first programming opportunity in college had me using machine language techniques to write a five card inventory program on an IBM 1620 with 4K of magnetic core memory. I followed that up with a couple of years on a Displaywriter. In recent years I've had better equipment, and I've learned how to make Agile XP and use cases a part of my daily life, but youthful and sophisticated users who have grown up with the web want lots of tricky stuff on their pocket-size devices. The problem for old guys like me is that the tricky stuff and the devices themselves were never dreamed of in the late 20th century when I was trying to get my programmer chops, but today's users want the stuff, and they want it now.
   
   So, since I enjoy trying to make this stuff, I have been recently engaged in a massive struggle to figure out how to drag my decades of programming experience with Basic, Visual Basic, MS Access, and client-server architectures into the brave new 21st century world of n-tier, the web, java, open source, and mobile, disconnected data gathering.
   
   On page 25 David H told me, the reader, that I was required to use ANT in order to work the examples in his book. This was not an option. By doing so he has shined a light on the yellow brick road to the geek promised land, and this old geek is now going happily down that road. Five stars for "Jasper Reports for Java Developers."



4. This is a pretty well written book, but it's lacking in two respects:
   
   1) The index is terrible. You literally have to thumb through the book to find what you're looking for. For a technical manual, this is inexcusable and greatly reduces the usability of the book.
   
   2) The examples are far too trivial and it never ups the ante so you can see JasperReport examples that are closer to "real world."

5 comments about Large-Scale C++ Software Design (Addison-Wesley Professional Computing Series).

1. I read this book back in 1998. It is the foundation for my understanding of the design of object oriented software. Prior to reading this book I programmed in C++ for more than 8 years. It was apparent to me that there were gaps in my understanding of how to design medium and large scale object oriented systems. This is a huge and dense book, but as I read through it, many times a light went on in my head (those ah ha moments).
   
   The book also gives specific details about consideration for the C++ language. C++ has changed over the years, and the examples do not use newer language features. I do not feel that this is important. The code clearly illustrates the ideas, which are not limited by the state of C++ at the time the code was written.
   
   Regardless of the object oriented language you use to develop software this book will teach invaluable concepts that I have not found explained elsewhere.



2. This book assumes you're already proficient in C++ and basic OOP design principles, and considers design at a level one higher than individual classes. You'll learn how to arrange your classes into modules and packages, and then how to organise communication within and between these higher-level constructs. Nonetheless, the book never forgets that the important thing is working C++ code, not diagrams and acronyms, so it's always practical.
   
   There are two core advantages to the designs discussed in this book: maintaining the correct level of abstraction, and reducing recompilation times. Performance issues always run the risk of becoming outdated fairly quickly, and to a certain extent, some of the timing material is no longer relevant. In particular, Sutter and Alexandrescu, in C++ Coding Standards, explicitly disavow the advocated method of external header guards. Additionally, although namespaces are mentioned, they are not used much, and the older method of using prefixes is recommended instead.
   
   The last part of the book drops down to more low level concerns, such as Schwartz counters, operators, and function arguments. This leans heavily on the likes of Effective C++, C++ Strategy And Tactics and C++ Programming Style, and to be honest, you'd be better off looking in more modern books for up to date best practices. For example, in this book assignment is implemented through the copy-and-destroy idiom, which is nowadays considered to be a mistake.
   
   But this is a big book, and you won't be buying it for the lower-level stuff, but for the large amount of higher level material that makes up the bulk. The main practices and metrics remain extremely relevant, the text is clear and well written. And there just isn't many other places where you can go and read about this sort of stuff. It's a must-read.



3. This is a superb book on software design. While clearly intended for those working on large-scale projects with a broad base of users, the principles discussed are rock solid for even the smallest project. It illustrates a higher level of C++ where objects are not just used because they can represent complex concepts nicely but because proper object-orientation is insurance against many coding evils - exactly the evils which can sabotage large-scale software projects.



4. I'll start with some negative points. Due to the age of this book, much of the example code is out ot date. In particular, no bool and namespaces. This means that the advice about not polluting the global namespace, and to use structs with static members instead ought to now be advice to use namespaces. There's little on the standard library. Coverage of templates (and their potential for code bloat and link time explosion) isn't great. Another issue is the enormous improvement in computer performance since this book was written. At the time, 100MHz single core subscalar CPUs were the order of the day. Now we have 2-3GHz multicore superscalar CPUs that are of the order of 1000 times faster. What sould have taken a week to build would now take.
   
   Some of the terminoligy used doesn't match that which I'm used to. For instance, I would tend to use composition and aggregation where Lakos uses HasA and HoldsA. I don't agree with what he calls internal linkage - basically it is everything that is not extrnal linkage. I'd add a third category, no linkage (e.g., macros, typedefs).
   
   Now some more positive comments. Part II is good stuff. There is a lot of detail on why components can become dependent, and ways of breaking those dependencies. He also explains quite well the disadvantages to such insulation (generally more code and/or slower). Unfortunately, I'm not aware of any easily available tools that generate the metrics that Lakos uses. Without such tools, you either have to perform lengthy analysis (or develop your own tool), or just guess roughly the state of your own system. The end of Part II goes off the boil a bit. Packages are just bigger components, and what is true for packages is also true for components. This leads to a bit of repetition. The section on startup issues is a bit fuzzy as to whether it is a logical design issue or a physical one.
   
   Part III is good enough, but a bit off topic I feel (again getting to logical design, whilst I think the book should have stayed more with physical design). Again, there are a few things that I don't entirely agree with. For instance, advice is given to be 'const correct' [good idea in my opinion], but to only use 'int' and to avoid unsigned types. My opinion on this is that just as you should be 'const correct', then you should also be 'sign correct'. You will have a hard time using just int in real C++ code. size_t is unsigned on all of the platforms that I know, and this is the type of sizeof, the dimension of arrays, returned by strlen and so on.



5. I have to admit, this book is nothing like I thought it would be. It has more C++ than anything else. It is not "large-scale software design with few examples in C++", no sir, it is "design of large-scale software specifically in C++" !
   
   Although not all of the ideas are restricted to C++, many of them do and the book is full of C++ code. Since I haven't done active C++ development for a while (currently digging into Python), it was rather difficult to read.
   
   In a single sentence, the book is about modularization techniques in C++. The purposes of such modularization are different, from speeding up the build process, having the program better understood or refactored, to allowing modular testing or reusing code. And the techniques are different in each case too.
   
   But it is all in C++. Friendship, inlining, const-correctness, abstract interfaces, .cpp and .h file naming, private/protected/public members and/or inheritance, pimpl idiom, initialization of static objects, signed vs. unsigned, that sort of thing. All this has rather limited usability unless you are practicing serious C++ right now.
   
   Again, many of the ideas behind do apply universally, but it is difficult to find them in the thick of C++. I have found a few interesting new ideas, but I have also skimmed over many chapters because it looked too C++-ish to read through.
   
   Worth noticing is that the book is dated (1996) and therefore does not cover such essential C++ features as namespaces and templates.
   
   Only if you are doing serious C++ development. Then it would be great.

5 comments about Foundation ActionScript for Flash 8 (Foundation).

1. I am a current animation student in California and Flash is one of the tools we are using. While I have developed some proficiency animating in Flash, the scripting tends to turn my brain to mush after a while.
   
   I picked up Foundation Flash 8 to learn some of the basics and have been using Foundation Actionscript for Flash 8 to gradually explore scripting. I am not a programmer but got through the first few chapters easy enough. The second half of the book is somewhat tougher but but filled with interesting chapters -especially the game chapter (chapter 10).
   
   I haven't quite cleared the hurdle of the later chapters, find them more challenging, but I keep the book on my desk to pick at stuff. It is well written and comprehensive. From my perspective as a non-programming 'art head' I'd say it covers beginner to advanced level topics by the end of the book; that's pretty cool because many books seem to be simple rehashings of the product manuals designed to part you from $40-$50 while giving you no new info.



2. I was completely foreign to ActionScript before picking up this book. I had previously read one book on understanding the basic flash interface (i.e. using the drawing/tweening tools), but this was my first crack at ActionScript. Getting through this book was very easy. Each chapter is setup in a way that explains a specific topic, runs you through a few examples using what you just learned, and then continues on with an ongoing website project that you develop throughout the book.
   
   Strengths: Writing is clear and concise, and doesn't feel like a programmer wrote the book. The context is a nice mix of theory and hands on practice to keep you interested while your learning some of the more complex topics. The teaching method looks to provide you with skills that you can apply and expand upon quickly, as opposed to just learning some commands and then throwing you out into the wild. The book projects are very well constructed and explained.
   
   Weaknesses: Some of the later chapters advance quickly. I blew through the first 350 pages, but after that had to significantly slow down to fully understand each topic. I also noticed that one or two of the online downloads are missing files for the book project. These are not neccesary if you are writing everything from scratch (correctly), but it did sometimes get in the way of comparing my solutions to the books.
   
   Overall I have been extremely satisfied with this book, and will most likely buy another Foundation guide.



3. I am new to actionscript, have watched a few Total Training dvd's, but they don't really go into indepth actionscript. Unless you buy all the dvd's which are expensive.
   This book was great. And has given my mind more of an understanding, especially of the process, of programming.
   I'm more a graphic designer, who is getting into web design, so if I can go from first page through to the end in 3 weeks and juggle a screaming 2yr old at the same time.....well then anyone can.( I am a stay at home dad!....by the way)
   Good to keep for reference. Buy it.



4. This is a great book for the designer interested in getting deeper into Flash through ActionScript 2.0. Primarily centered around web-based projects, with the occasional game project, Sham et al. lead the reader through basic programming fundamentals from a designer perspective. The reader is assumed to be mildly frightened by looking at code, but still interested in learing it. I can sympathize that many designers could be in this boat.
   
   The language of the book is very non-technical and it's presented in a light-hearted manner to ease you into some difficult concepts. The authors do a great job of tricking you into getting excited about programming. So if you're a web designer who has always been impressed by what programmers can do, but were a little uncomfortable trying to just jump in on your own, this is THE book for you.
   
   I have two warnings and one critique.
   
   The first warning is that this is a Flash 8 book - hence ActionScript 2.0. The second warning is that almost all the projects in the book are web-based instead of game-based. Now it's Flash, so it kind of comes with the territory, and there is a full chapter devoted to making a game. However, the perfect book for me would be this exact same book, but centered almost completely around game-based projects. If you're strictly looking for that, this book isn't for you. I don't care as much, and there's still a lot to learn, so I don't regret purchasing the book.
   
   My critique is regarding the book-long project where you make a website that uses ActionScript (the Futuremedia site). It's a case study where you can apply some of what you've learned to a "real" project. My problem with it is that you don't seem to learn a whole lot about ActionScripting by going through it. The authors (or whichever individual wrote the project) seem to be really proud of this project - proud in the sense that they like themselves for it - and you can tell by going throug it. Plus, its more content-oriented. There's much more to learn from everything else, so I'm just skipping the project and skimming over it whenever it's time to work on it a little (which isn't a whole lot anyway).
   
   Overall, it's a great book so far (I'm about 1/3 done) and I'd recommend it to anyone who's new to programming and wants to learn it through ActionScript 2.0. Sham has an awesome ability to explain programming to a designer.



5. I am not too far into this book, but so far it is everything i had hoped for. I have been using Flash for 6 years but never ventured into ActionScript.
   This book explains things well for the no-ActionScript-knowledge user.
   
   Great book and at $9 (80% off) when i got it, i would have to have been raving mad not to buy it.
   
   Good One Amazon :))

No comments about Second Person: Role-Playing and Story in Games and Playable Media.

No comments about MCITP Self-Paced Training Kit (Exam 70-237): Designing Messaging Solutions with Microsoft® Exchange Server 2007.

5 comments about Embedded Linux Primer: A Practical Real-World Approach.

1. Wow!
   So far the book proves that embedding Linux while not easy can be fun and interesting. You never know what Tux will do during his startup sequences, even if you did indeed write the stuff the kernel is using for that series of startup steps.



2. I am an experienced embedded developer that just inherited an embedded Linux-based project already in progress. As there happens to be no one else at my company with any embedded Linux experience, I automatically became the de-facto Linux expert and I needed to come up to speed on a lot of topics very quickly. I found this book to be an excellent survey of the must-know topics for the embedded Linux developer. It also contains many references to the most definitive sources of information on the various topics. Highly recommended for coming up to speed on embedded Linux.



3. This book is very well organized, and provides a good level of detail of the topic. I do recommend it.



4. This book, the CALAO SYSTEM USB-A9260 card, an eeePC and a cross over cable is all that you need to study embedded system everywhere (even along the Seine river in Paris - yes I did it !).
   The chapters about the U-BOOT bootloader, the BUSYBOX embeded Linux and an extra piece of information on the JFFS2 file system are welcome. If the cross-development environment chapter had been about BUILDROOT, this book would have been THE BOOK for the present embedded Linux based systems designers.



5. For those engineers who start their first embedded Linux project, this book is a must have. The book is not for those who want to understand how kernel runs but it gives you the most important concept and work flow to bring up the OS on your development board. The author also provides a useful further reading list in case you want to dig more. A very practical and clearly written book and I would recommend it to those who have solid experience in embedded development but just start to explore in Linux.

1 comments about Writing Secure Code for Windows Vista (Pro - Step By Step Developer).

1. Initially I didn't liked Windows Vista. A resource hog, some incompatibilities... But I had to use it at work so I installed it and worked with it for two months. After that, I really like the security features it has, but I felt like missing more details about specific topics... So I decided to buy this book.
   
   Writing Secure Code for Windows Vista comes as a, mostly C++ oriented (although contains some C# examples), "how to use all new features" book. Very well structured, with lots of code examples, best practices, direct to the topic, and one thing I liked a lot: very sincere. If something is working bad, the authors state it clearly (for example, the Windows Firewall API, which has bugs), and they even provide workarounds to avoid them.
   
   Down to the content, the book covers a lot of topics: New safer C functions, banned APIs, new APIs, UAC, token manipulation, integrity levels, code signing, virtualization, buffer overrun defenses, IPv6, Secure Socket extensions, Windows Firewall (Vista version, of course), IE7 security mechanisms & defenses (very interesting), Windows services development best practices, protected mode API and DEP, and the new CNG (Cryptography API: Next Generation).
   
   Even if you don't usually develop with C++ I highly recommend this book. With it you will learn a lot about all the new security features of Vista. You just need some basic knowledge of standard Windows security features and some C++/API programming.

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.