The code examples in the book can be found online. While several of them are quite helpful, this book is by no means an exhaustive reference, nor does it clearly articulate the basics. See the w3schools website for this.

Are you a developer? If you are, then this book is for you. Author Sal Mangano, has done an outstanding job of writing a 2nd edition of a book that offers hundreds of solutions to problems that developers regularly face in both versions 1.0 and 2.0.

Mangano, begins by briefly explaining the greater sophistication and complexity of Xpath 2.0. Then, the author shows you that almost anything one wants to do with strings can be done within the confines of XSLT; as well as, how the new features of 2.0 make it that much easier. The author then shows you how to push the limits of XSLT's mathematical capabilities, even though XSLT was not designed to be the next great Fortran replacement. Next, he describes date and time recipes that augment an area standard that XSLT 1.0 currently lacks. The author continues by exploring the problems XSLT was specifically designed to solve. Then, the author presents an overview of XSLT 2.0. Next, he provides recipes that control how text extracted from XML is rendered for layout on the terminal, on the text editor, or for import to programs that require delimited data, such as comma separated values. The author then covers XML transformations. Then, he presents a treasure trove of recipes that demonstrate XSLT as a query language. The author continues by demonstrating solutions to problems that arise when generating web content, including links, tables, frames, forms, and other client-side transformation issues. Then, he describes the transformation of raw data into bar charts, pie charts, line plots, and other graphical components. Next, the author shows you the advantage gained from representing the data that drives code generation in XML and illustrates how XSLT is ideal for writing code generators for C++, Java, and XSLT itself. He also includes some advance uses of XSLT. The author continues by providing extensive coverage of XSLT extensibility using Java and JavaScript. Then, he demonstrates useful techniques that can help you transform misbehaved XSLT programs into functional ones, even if you don't have a nature XSLT debugger handy. Finally, he pushes the XSLT envelope to show how XSLT is far more than just another styling language.

This most excellent book has recipes that range from simple string manipulation and mathematical processing to more complex topics such as extending XSLT, testing and debugging XSLT stylesheets, and creating graphics with SVG. More importantly, the recipes in this book will guide you through many different ways of applying XSLT.

Sal Mangano's XSLT Cookbook: Solutions And Examples For XML And XSLT Developers covers all the advanced features of the Extensible Stylesheet Language Transformations, a tool for processing XML. It's a daunting tool even for developers, and XSLT Cookbook helps developers with a set of problems and answers which cover all kinds of performance issues, from the basics of creating charts, graphics and generating code to handling data, processing math, and designing. Recipes cover all levels of use and provide developers with plenty of real-world examples.

XSLT is one of those technologies that has been around for awhile, but it feels like not enough great references are out there for developers. When this is the case for any technology, any new guide that comes out is a breath of fresh air, because it might be the right tool to turn a regular developer into a SUPER developer. With 'XSLT Cookbook' by Sal Mangano, XML and XSLT programmers finally have a guide that they can really sink their teeth into, with real solutions to everyday problems. Jam packed with over 700 pages of material, this book covers the major important topics that one would expect to read up on: string manipulation, math processing, date/time handling, XML conversions to plain text, querying XML documents with XSLT... the list goes on and on.

If you use XSLT on a regular basis or you have a project that is going to use XSLT and/or XML, you will be hard-pressed to find a better reference out there on the market today for your needs and this text will no doubt present either the solution you are exactly looking for, or provide a basis for achieving the desired solution you are aiming to find.

***** HIGHEST POSSIBLE RECCOMENDATION

[Review of 2nd edition]

One of my favorite development methodologies is "R&D"... "Rob & Duplicate". And an important source of inspiration is often the O'Reilly Cookbook series. For XSLT, you now have an up-to-date wealth of samples to pull from... XSLT Cookbook (2nd Edition) by Sal Mangano.

Contents: XPath; Strings; Numbers and Math; Dates and Times; Selecting and Traversing; Exploiting XSLT 2.0; XML to Text; XML to XML; Querying XML; XML to HTML; XML to SVG; Code Generation; Vertical XSLT Application Recipes; Extending and Embedding XSLT; Testing and Debugging; Generic and Functional Programming; Index

If you've never seen an O'Reilly Cookbook, the concept is pretty simple. Each "recipe" consists of a problem description, a solution, and a discussion of how the solution addresses the issues, along with any observations that can shed light on the situation. These recipes are then grouped together by general problem types so that you can easily find an area that might offer up a quick answer to your particular problem. In this book, Mangano expands upon the 1st edition that covered XSLT 1.0. The 2nd edition now covers the updated XSLT 2.0 standard, and offers up both 1.0 and 2.0 solutions and discussions to many of the problems. As such, you will find value in the material regardless of your particular version usage. So for instance, let's say I have an XML file that needs to be reformatted into a second file to meet some formatting requirement. By checking into the XML to XML file, I'll find solutions on turning attributes into elements, elements to attributes, renaming elements and attributes, and so on. Tutorial books will teach you the syntax for doing stuff like this, but they can't anticipate real-world solutions. Cookbooks assume you already know what you're doing, and they go right to solutions.

Personally, I find a number of uses for books like this. There's the obvious, which is to find an exact (or nearly so) answer to your particular problem. But stepping away from the "immediate" need, there's always the opportunity to read through the recipes and see how others might code a solution. You can learn new coding techniques that way, as well as see features of the language that perhaps you never noticed before. Sort of like having a guru sitting next to you at work...

Assuming you're past the point of beginner, the XSLT Cookbook is probably the second XSLT book that you want to have on your bookshelf. If it helps you solve a couple of problems and save a handful of hours in the process, it'll more than pay for itself...

Excellent book to get the basics in many different areas of using XSLT. My focus is converting XML to HTML so naturally I was mostly intent on reading those chapters; the rest of them had academic value to me.
The problem I find with this book is that it doesn't focus on XSL tools and how to write snippets of code for them (I am using XSLmaker and didn't find anything on it). Maybe the book was not totally up to date. In any case, modern XSL development is driven by visual tools like XSLmaker that let you code Xpath filters or define XSL code for visual HTML fields - and that sort of integration was what I expected.

Still, I gleamed few useful tricks that saved me some time, so the book was worth it after all.

I needed something quick that had lots of examples of transorming text in one format to other text in another format. Had to tabulate on a text file with rows and columns of fixed length some data elements found in a XML file. This book showed me how. The $35 alone saved me several hours of my time. Sure, you could search the web, and maybe you would could find exactly what you need. But why hurt your eyes, when the price is low enough to have this simple and efficient tool called "book", at your desk, anytime you need to transform a xml file again.

I really wish all my computer books were this easy to read when confronted with a difficult subject matter. Chapter after chapter of good reading, which aids in the development of a skill on a subject matter that is often written by other writers in a manner that is terse and verbose. Sal got this one down pretty good. Caveat emptor, come to this book prepared with the basics.

The O'Reilly Cookbook series is a great place to find answers to really hard problems. I like the series because I can go to the "cookbook" subject I'm having trouble with, leaf through a few pages, and see an answer to a problem that is similar to my own. The XSLT Cookbook is very similar in structure to the other "cookbooks", but with an XSLT flavor.

After going through the various recipes in this book, I can honestly say that I am amazed at the kind of things you can do with just XSLT. You can do more than just reformat XML to look nice on an HTML page-you can even use it to calculate statistical functions! Even if you're not planning on calculating a combinatoric, just looking through some of these patterns will make you a better XSLT programmer.

One nice thing this book provides beyond the recipes is a discussion on how to extend XSLT via SAXON or Java. There is also discussion on how to use XSLT via Perl or Java.

I was very impressed by the amount of time and thought that was put into the creation of many of these recipes-not only are many of them really, really hard to do, but they're also things I've seen a real need for in the real world. XSLT programmers, do yourself a favor and take a look through this book before you hurt your brain with your next assignment.

This book is invaluable as an adjunct to some of the reference works, such as O'Reilly's XSLT book. This book provides practical examples of how to solve common problems you face when you develop with XSLT. The chapters on querying and selecting and traversing are worth the price alone.

Some other reviews have said that this is not a book for beginners, which is true. You need to understand the mechanics of XSLT first to get the most out of the book. That's not the real value, however. This book is great because it shows you how to write XSLT well. This is a value that a simple reference will not provide.

Probably one of the best XSLT books--at least, that I have seen. Well-suited for all user levels...top-end topics include SOAP, WSDL, and SVG. An indispensable resource for the XML developer.

This is not a book for beginners. Not for beginning programmers, and not for advanced programmers who don't know much about XSLT. An introductory chapter or two explaining XSLT, and maybe a few really simple examples (10-20 lines each), would have gone a long way towards making this book more useful. If you already know XSLT pretty well, though, this could provide some useful sample code.

If ever there were a publishing company that could make XML-XSL easier to understand it's O'Reilly. Being somewhat new to the concept of XML transformations this book proved fairly intuitive, although I would recommend purchasing this book as a chaser to one that is a bit more elementary if you're just starting out.

There are plenty of good working examples with detailed instruction and code. O'Reilly also provided the CD, which, as always, was a tremendous help for implementing some ideas we got from their code into our environment.

The authors also provided hands-on reference for creating solutions in the XML-XSL Transformation domain. It covers areas from simple string operations to SVG generation to extending XSLT with Perl, JavaScript and Java.

Overall, I do recommend this book, but as I said before this is really not the book to get if you don't know what XSLT is.

XSLT Cookbook presents specific solutions to situations you come across when using XSLT. While the book can help solve an immediate problem it can also be used as an intermediate or advanced level text to get a better understanding of XSLT and how to write stylesheets.

There are fourteen chapters dealing with topics such as Strings, Dates and Numbers, Selecting and Traversing, XML to HTML, Code Generation, and Testing and Debugging. Each problem has a short problem statement, a solution, and a discussion of the solution. The solution discussions often describe alternates and why they were not selected as the preferred solution.

I have not read the entire book yet but picked chapters that were of interest to me. The Selecting and Traversing and Testing and Debugging chapters contain approaches I could use right away. The Generic and Functional Programming chapter was very interesting and I wish this book had been available in mid-2002 when I was doing code generation work with XSLT. Good stuff in every chapter I have read!

This is a book that most, if not all, XSLT developers should have. For beginners it provides concrete examples of how to use XSLT. For more advanced developers it provides a good reference for solving that problem you are trying to solve.

What an incredible resource this book is! I am using XSLT to transform XML data into flat files that are delivered to a legacy DOS application, so the chapters on text and string manipulation were extremely helpful. In addition, the author has illustrated examples that covered almost every road-block that I ran into while developing XSLT files. I also like the approach in illustrating generically useful examples for applications in general, not just web applications. An assential resource for anyone wanting to implement XSLT in a hurry.

The XSLT Cookbook offers more than one hundred code solutions to common XSLT problems. The covered topics range from string operations, handling dates and numbers to converting xml to various formats, like text, HTML or SVG.
The author also included some speciality solutions for working with Visio and Excel documents or generating XTM Topic Maps. The last chapters of the book cover some more advanced topic, like extending XSLT and testing stylesheets.
As it is a Cookbook, the beef of this book are the code examples. All examples I tested so far are of outstanding quality and work great. For the most problems you will encounter when writing stylesheets, this book offers an example. Just look it up and you are there.
The very high quality of this book and it's code examples is impressive. The author Sal Mangano sure put a lot of work and research into this book. And the expertise of Jeni Tennison, as technical reviewer, and Simon St.Laurent, as editor, sure were an important factor in achieving this quality standard.

If you are an absolute beginner, you probably should start with a more tutorial style book, but as soon as you have some basic knowledge of XSLT, this book is a great reference for XSLT solutions.

What pleases me so much about this book, and it really does please me, is that Sal Mangano writes fantastic, well thought out templates for use in your XSLT stylesheets, and tells you what makes them so wonderful. Even more importantly, he's willing to show you alternatives to the solution he provides and explain why they're not optimal.

This book is like a computer science class taught in XLST, and while not the most thrilling subject in the world, it's certainly well-planned, well-executed, and well worth having on your bookshelf.

Summary: Excellent Examples but Limited Use for Beginners

I'm half-way through the "XSLT Cookbook" and I must say I like this author's style. Compared to my level, Sal Mangano is a master at writing style-sheets; however, I never feel as though he is writing down to me. While most of the book is composed of cut-and-dry material, Mr. Mangano also provides just enough (but no more) interesting and slightly humorous ideas to prevent distraction.

The examples are pretty useful on their own for the programmer who is just learning the language), and they also prompted some stimulating ideas for my own projects. I especially find the chapters "Extending and Embedding XSLT" and "XML to XML" helpful (although the example in section 12.6 seems incomplete with no include statements). I would have preferred a little more details on embedding Saxon in Java, but the references provided (and the sample chapter of "Java and XSLT" from O'Reilly's web site) more than enough details to get me started.

Even though there are several highlights of the book, the solutions presented are a little hard to figure out (since, as a beginner, I don't yet read the Extensible Style sheet Language fluently) so a second book or tutorial is recommended for those who are generally unfamiliar with or unconfident using XSLT and XPath. The second edition should definitely have a **brief** reference or tutorial for 'us' beginners. In chapter two, he also mentions discussing trig functions, but Mr. Mangano only gives one sentence and no examples for their XSLT solutions. Although I can guess at their implementation (using a series that I constantly use in my Complex Analysis class), I wish the author would still have included such an example.

Despite these flaws, I highly recommend Sal Mangano's manuscript as an addition for anyone who is learning XSLT or just wants a quick solution to a common problem.

The book is an excellent practical hands-on reference for
creating solutions in the XML-XSL Transformation domain.

It covers areas from simple string operations to SVG generation
to extending XSLT with Perl, JavaScript and Java.

The author Sal Mangano has good working examples with detailed
descriptions of the code. This makes experimenting with new
code relatively painless.

Being an experienced XSLT developer I found the book easy to
follow. However people new to the concept of XML transformations
would do well to get a basic understanding of the matter before
diving into building solutions using this book.

Having a copy of the XSLT Cookbook during the development
phase of the LCRA.org website project would have reduced the
time needed to craft a good sustainable solution, and reduced
the amount of code I had to redesign to be modular and flexible.

An example is the recommendation : "Prefer 'selecting' and
'matching' over 'filtering'" pg 114, para 3. This allows for
flexible XML schemas.

A companion CD with working example code and a searchable
text of the book on the CD would have been appreciated.
The website at Oreilly does have a downloadable zip file
of the examples.

All in all well worth the $40.00 price of the book,

Neeraj

Although I sympathize with the previous reviewers complaint about source code organization, this is partly due to the fact that more variations are included in the source distribution then the book itself. To remedy this issue a new source code zip file has been posted to the O'Reilly site that contains README files cross-referencing source code to book examples. I hope this creates a more pleasurable experience for my readers.

p.s. To avoid biasing the rating I gave myself the current 4 star rating although I humbly think most readers will have a 5 star experience!

The outlook of this "XSLT Cookbook" is refined: giving luxurious accommodation to experts, without scaring beginners away. Most of its 450 pages were dedicated to a sensible problem-solution-discussion pattern, (which readers should appreciate).
Apart from analyzing how to manipulate XML documents with Stylesheets, elaborate methods of using SVG and XSLT to plot graphs and charts were stressed. The otherwise tricky art of creating SOAP documentations from WSDL (using XSLT) was reduced to nursery rhymes.
I am satisfied by this author's method of tackling XSLT problems. Still, when the next edition of this book appears, I would expect to see a better job done: as regards all those precursors, which facilitate the processing of Visio documents in XSLT.
In conclusion, I would say that this is one of the few eXtensible Stylesheet Language Transformations books, which did not discriminate between beginners and advanced learners. All are welcomed! A great value indeed!

One would think that such a code-heavy book would need decently organized source code to make it easy to follow along. Unfortunately I found this not to be the case.

Trying to relate examples in the book with the downloaded source has been truly an unpleasant experience.

For example, Chapter 2 shows an xml called numbers.xml which serves as input to most of the examples in the Chapter. Although there's a numbers.xml file it the directory source, it only contains about 10 lines, while the book example contains about 27 lines. But if you look in the Chapter 14 sample code directory, there is a numbers.xml file which corresponds to the sample in Chapter 2.

I own both the XSLT Programmers Reference by M. Kay and XSLT by D. Tidwell. Both these books helped me learn XSLT; however, I am quite sure Mangano's book will help me master it. To be fair, I have only read the SVG chapter in detail but it provided such a treasure trove of immediately useful solutions that it alone was worth the price of the book. Sal Mangano writes in a no nonsense style that gets to the heart of what an XSLT user needs to know to get immediate results. However, far from just providing a grab bag of reusable code snippets, the XSLT Cookbook provides welcome insight in how to structure XSLT transformations.

My only complaint is that the code for the book was not yet available at the O'Reilly web site. However, as the book was just recently published I am hopeful it will be posted soon.