O’Reilly recently released the book Beautiful Testing, a collection of essays about testing and QA in general. As I mentioned earlier, I wrote an article in that book on (unit) testing XMPP protocols, using Swift as a motivating example. Since the book’s scope may (oddly enough) not always be as interesting for developers in general, I released my article under a Creative Commons Attribution license (thanks to the good folks from O’Reilly for encouraging us to do this), which you can find here (or directly from my Git repository). The original excerpt from the book (including the index, list of biographies, and all the fancy artwork) is also available for download under the same license.

I of course encourage you to buy either the PDF or dead tree version of the book, as all the proceeds of the book go to charity.

When I was a kid, I used to be fascinated by Swiss clocks and watches (actually, mostly anything that was made in Switzerland). However, my attention in watches seems to have faded shortly after I got my very own black & red strapped Swatch: only a few years later, I replaced the Swatch with a digital Casio with built-in calculator, because it looked flashy and cool. I have to admit that the watches I wore (if any) haven’t really improved much since then. However, since I recently came to be without a timepiece again, I took the opportunity to read up on watches before buying a new one. I ordered the first well-rated book on the subject I could find, which happened to be Gene Stone’s The Watch. It turns out that this book was one of the most entertaining books I recently read, and I must admit I have become a watch fanatic ever since I read it.

The Watch begins with a history of time, covering all kinds of timekeeping tools, from the pyramids of ancient egypt, up to the cell phones of today. After this brief history, the author motivates his choice of 50 brands that he describes in detail in the remainder of the book. He concludes the introduction with an entertaining comparison of the watch manufacturer scene with an old European court, consisting of a king, a queen, a prime minister, a knight, and so on.

The main part of the book consists of an in-depth description of 50 of the most notable and famous historical watch brands out there, old and new, literally ranging from A (Lange & Söhne) to Z(enith). The book tells the (often very extended) history behind each brand, the multitude of relations between the different watchmakers, and the most famous watches of each brand. These stories are a very interesting read, and serve as an excellent crash course into the world of watches for newcomers like me (whose knowledge of brands is limited to the obvious Rolex, Swatch, and Omega). However, what really puts the cherry on the cake are undoubtedly the 500 gorgeous high-quality pictures of watches and their movements, depicted in extremely high detail. On any given day, I find it fascinating to pick up the book, flip through the pages, and enjoy just looking at these photos for a while.

After the theory behind the watches and their history, the last part of the book focuses on the actual owning, exploring, and collecting of watches. Besides a handful of tips from the author, this part comes with several testimonies from different people, talking about how they got interested in watches, why they are so fascinated about them, and which one is their ultimate favorite. On top of this, the author created a few top 10s of watches, including “models that everybody should know”, “models that are fun to look at”, “models that look good”, and “brands to look out for”. Again, very valuable information for the uninitated like me.

You can feel that the author has a passion for watches, knows what he’s talking about, and put a lot of love into this book to share his passion and knowledge with the rest of the world. All this makes The Watch both a fascinating and entertaining to read, or, if you don’t feel like reading, a nice way to feast your eyes on pretty shiny pictures.

If, like me, you’re interested in reading even more about watches after finishing The Watch, I can recommend Cult Watches: The World’s Enduring Classics by Michael Balfour. Where The Watch discusses the history of many brands and a variety of their collections, Cult Watches picks out 30 specific “cult” watches (including my favorite, Jaeger-LeCoultre’s Reverso), and tells the detailed story behind each watch and its manufacturer, also accompanied by a lot (though not nearly as many) of high-quality photographs of the insides and outsides of these timepieces. And although most of the watches in this book are mentioned in The Watch as well, some brands that are only mentioned briefly in that book (such as Longines) are mentioned in more detail in Cult Watches. All this makes Cult Watches a nice addition to Gene Stone’s broad reference book.

All examples are built using the lightweight SleekXMPP Python XMPP library. In fact, SleekXMPP is so lightweight that we included a version in the source bundle, making it even easier to get started implementing your own bots and components.

Do bear in mind that these examples only serve illustrative purposes for the book, so don’t expect very robust code. Although making this code fail-safe is not really our primary goal (since that would involve a lot of code that would only distract the reader), we do welcome bug reports or fixes.

The code examples are available as a source package, or directly from the Git repository (mirrored on GitHub). We will soon put a link to the package on the book’s webpage.

First of all, I used Sleek Migrate to retrieve the roster (and other) data from the server, and store it in the standard XEP-0227 format. I extended the tool a bit such that it supports Openfire’s User Import/Export format, a format generated by an Openfire plugin that is distributed with the server software by default. Using this format as input for Sleek Migrate avoids the need to create a user file manually. The changes I made to Sleek Migrate are currently available from my Git repository, awaiting to be pushed to the main repository.

I then wrote a short script that populates the Prosody data dir with the server data from the XEP-0227 XML file. Currently, the script only generates roster and account data, but adding vCard and Private XML Storage (used amongst others to store MUC bookmarks) should not be very hard. Until Prosody creates a native XEP-0227 importer, you can get the script from my Git repository.

The custom stylesheet is based on the standard DocBook XSL XHTML stylesheet. However, instead of inserting an HTML header, it inserts PHP calls to include the WordPress headers and footers. The only tricky part of this is to tell WordPress what the title of the resulting page should be. I hacked this in by creating a class with the bare minimum fields required by wp_title() (which is used by WordPress to print the title of the document). The resulting template looks like this:

<?php
  require('../wordpress/wp-blog-header.php');
  class MyPost { var $post_title = "My Title"; }
  $wp_query->is_home = false;
  $wp_query->is_single = true;
  $wp_query->queried_object = new MyPost();
  get_header();
?>
<div id="content" class="narrowcolumn" role="main">
  ...
</div>
<?php
  get_sidebar();
  get_footer();
?>

The DocBook kit is available from my Git repository (or on GitHub, or as a ZIP file). More information about the kit can be found here.

Although there are many types of testing being done in the XMPP world, the chapter focuses on the beauty of testing the functionality of XMPP protocol implementations. After a brief introduction on XMPP, it starts out with a description of unit testing simple IQ request/response protocols, and then gradually moves on to higher-level testing of more complex, multi-stage protocols such as session initialization. As you might expect from a developer like me, the chapter is quite heavy on the (C++) code, but I’m told it compensates for the rest of the book

As with all other books in the O’Reilly “Beautiful” series (which started with Beautiful Code, but has since been followed up by Beautiful Architecture, Beautiful Teams, Beautiful Security, and Beautiful Data), all proceeds of the book go to charity, in this case “Nothing But Nets” (which provides mosquito netting to malaria infested areas of Africa). This means that I can plug this book as much as I want, and still have the feeling I’m actually doing a noble, unselfish thing. (contrary to when I casually mention that you can buy our book XMPP: The Definitive Guide at very sharp prices these days). Some time after the book’s release this summer, I will even make a free version of the chapter available here, so check back soon!

Starting a DocBook project requires a few elementary tools to be installed:

• The DocBook XML schemas. These are used to validate whether your document is a legal DocBook document.
• The DocBook XSL stylesheets. These are used to transform your DocBook input file into other formats, such as HTML or XSL-FO (a format which can be converted to PDF)
• XML and XSL processing tools. These tools take the schemas and stylesheets mentioned above, and apply them to your document to do the actual checking and transformation. I use xmllint and xsltproc (available out of the box on many platforms and distributions), but other tools can be used as well (e.g. Saxon or Xalan)
• An XSL-FO processor, to transform the intermediate XSL-FO format generated by the stylesheets to PDF. I use the Free Apache FOP, but commercial tools such as RenderX XEP and AntennaHouse are very popular for this too.

Once you have all these tools, you need to tie them all together to be able to get from your DocBook file to your desired output format, such as PDF or HTML. Because this involves quite some boilerplate scripting, I created a DocBook kit to make this as light as possible. The DocBook kit comes with a Makefile, which you can use to do all the work for you. The kit also automatically downloads the DocBook XML schemas and XSL stylesheets, making it possible to start working on a DocBook project on a machine with only some basic tools (xmllint and xsltproc) installed.

To use the kit, simply drop it in the directory of your project, and create a minimal Makefile such as the following one:

# The toplevel DocBook file of our project
DOCUMENT = MyDocument.xml

# Include the DocBook Kit's makefile rules
include docbook-kit/tools/Makefile.inc

This makes several make commands available, such as:

• make, make pdf, make html, make txt: Creates an HTML, PDF, and/or TXT file of your document.
• make check: Validates your document syntactically.
• make check-spelling: Runs a spell checker on your document.
• make package: Creates a flat DocBook file (i.e. one with all the parts included using XIncludes expanded), normalizes all figure names, and packages the result up into a tarball.

The makefile also tracks the dependencies of the document, making sure that your document is rebuilt whenever one of its dependencies (e.g. images, document parts included using XInclude) changes.

Besides tools, the kit also provides a customization layer around the standard XSL stylesheets. These customizations change fonts, spacings, and other presentation parameters for the output document. You can use these as an example on how to make your DocBook document look the way you want. Detailed information on using and customizing the DocBook XSL stylesheets can be found in Bob Stayton’s DocBook XSL: The Complete Guide.

The DocBook kit is available from my Git repository (or on GitHub, or as a ZIP file), and comes with an example of a simple project using the kit. More tools and features will be added in the future.

PDF

Until we launch the project and its website, you can subscribe to the Swift blog and identi.ca group to stay up to date with the latest news and developments around the project. Thanks to Dave Cridland for lending us his graphical capabilities and drawing us a pretty logo.