Off The Grid
   Simple listserv
   xml tools
Karel as an adult


Just a collection of random rants that I can't really place anywhere else.

2016-07-20 Fswatch 1.09
2016-05-04 Another fswatch update
2016-03-24 fswatch updated
2016-02-22 OTG Price Claimed
2016-02-01 File System Watcher fswatch
2016-01-05 Commandline flag parsing in Go
2015-11-19 Phoning the Dutch Vehicle Registration
2015-11-09 FE 1.05 released
2015-09-28 Bad Horse
2015-09-24 A generic attribute holder class in Python
2015-08-05 Autorotating jpegs according to EXIF tags
2015-04-15 0MQ in Python
2015-04-13 FE update
2015-02-23 Perl Course notes moved
2015-01-13 For my dad
2014-12-11 Peugeot 307 te koop
2014-11-20 Combining tornado.web StaticFileHandler with dynamic handlers
2014-11-05 Pushing scripts to servers using ssh
2014-11-03 Python3 argparse Mini HOWTO
2014-10-30 Handling secure httponly cookies with Python3 and tornado.web
2014-10-29 Overloading libc Calls
2014-10-27 Python Bootcamp Notes
2014-10-06 Custom Squid Proxy Authentication
2014-08-30 CyclicLog
2014-05-02 Playing with Python
2014-04-08 Kalk 1.38
2014-03-18 Closing C++ lecture
2014-02-26 Spring Cleanup
2014-02-26 Gravity error
2014-02-03 More on the knight tour
2014-01-28 The circular knight tour
2014-01-24 A Perl IBAN Checker
2013-10-16 Go2SEPA is live
2013-07-24 AJAXy Fileuploads with JQuery
2013-05-23 The Ticket
2013-04-24 Who is leeching my Facebook
2013-04-15 Time for a compact Coolpix
2013-04-15 Selling my Peavey amp
2013-03-28 encfs Helper Revisited
2013-03-15 c conf 1.17
2013-02-25 Flitsers op de Nederlandse wegen
2013-01-14 OTG Revisited
2013-01-11 Kalk revisited
2012-12-12 God is coming
2012-11-29 Strangely disturbing
2012-11-27 How to sneeze on a motorbike
2012-11-23 Een aanslag uit de toekomst
2012-11-22 More voluntary layoffs
2012-10-17 Browser fingerprint
2012-10-15 Site layout revamped
2012-10-14 Crossroads performing well
2012-10-08 The saddle seat
2012-09-30 Sudo Exploit
2012-09-26 Technomona is live
2012-09-19 A Perl to HTML Prettyprinter

2012-09-17 Playing with Moose

I've been playing around with Catalyst, the MVC framework for Perl app servers. All tutorials and the book The Definitive Guide to Catalyst work with Moose - so as I'm trying out Catalyst, I decided to dig deeper into Moose. Here's a tiny introduction.

So what is Moose?

Moose is basically a framework, or scaffold, to ease the pain of retyping accessors of Perl classes. Typically, if you have say a class called "Person", you'll have an accessor "firstname" that is both a getter and a setter:
  sub firstname {
      my ($self, $firstname) = @_;
      $self->{firstname} = $firstname
	if (defined $firstname);
      return $self->{firstname};
Of course you'll have tons of such accessors, for a last name, a middle name, sex, color of hair, shoe size... Retyping this gets really bothersome after a while. Perl already has some nice "gadgets" to simplify this - e.g., AUTOLOAD-ing (see my blog post on this subject). But still, Moose is really nicer.

Then, in standard Perl object lingo, you'll have the preamble of the class, starting with "use strict / use warnings", and then going into "use Exporter" and defining all methods that you would like to export. Moose makes all this really superfluous, just one statement "use Moose" is all it takes.

All this, and much more, is greatly simplified when you use Moose. In addition, Moose offers out of the box roles of your classes, hooks for pre- and post-modification of object fields, coercion of values (e.g., string to date), and loads more. Moose really is complete. But, unfortunately, at a performance cost. Here's an evaluation.

For example.. invoices

I'll illustrate Moose with a tiny program that displays an invoice, such as illustrated below. There are the following parts to the invoice:

  • An invoice has an ID.
  • An invoice also has a customer.
  • The customer has a name and an address.
  • Furthermore, the invoice has a number of invoice lines.
  • Each invoice line has a description, a unit price, and a quantity.
  • The invoice therefore has a total price.
Here's a sample. The invoice ID is 2012-09-17785, the customer is Charlie's Cheeses in Alexandria. There are three invoice lines, concerning Cheddar, Roquefort and Emmentaler. Finally there's the total:
                                   I N V O I C E
     Charlie's Cheeses
     1415 River Rd., Alexandria, 34557 MN
     Description                       Qty    Unit    Subtotal
       Cheddar, 1kg                      2   12.50       25.00
       Roquefort, 100gr                  1    2.35        2.35
       Emmenthaler, 5kg                  3   49.90      149.70
     Total:                                             177.05

A Customer

Let's dive right into the code. Here's a Perl module to handle a Customer, having a name and an address. The Customer may be constructed having the name and address right in the call to "new", as in:
  my $c = Customer->new(name    => 'Customer name',
                        address => 'Some address');
  print "Customer is called ", $c->name, "\n",
        "and has the address", $c->address, "\n";
Alternatively, the fields can be set separately:
  my $c = Customer->new;
  $c->name('Customer name');
  $c->address('Some address');
  print "Customer is called ", $c->name, "\n",
        "and has the address", $c->address, "\n";
On the left side is a listing with the "standard" Perl class code, a-la Tom's Object Oriented Tutorial (try perldoc perltoot to see it). On the right side is the Moose equivalent.
package Customer;
use strict;
use warnings;

use Carp;
use Exporter;

our @ISA    = qw(Exporter);
our @EXPORT = qw(new name address);

sub new {
    my $class = shift;

    my $self = {};
    bless $self, $class;

    my %opt = @_;
    for my $key qw(name address) {
	$self->{$key} = $opt{$key} if (defined $opt{$key});


sub name {
    my ($self, $name) = @_;
    $self->{name} = $name if (defined $name);

sub address {
    my ($self, $address) = @_;
    $self->{address} = $address if (defined $address);

package Customer;
use Moose;

has 'name'    => (is => 'rw', isa => 'Str');
has 'address' => (is => 'rw', isa => 'Str');

no Moose;
Pretty impressive huh? Don't mind the last two lines ("no Moose" etc.). They clean up the scaffolding. Details are in the docs ;-)

Moose's "has" method basically sets up the internal data fields and the accessor methods. In this example it's instructed to set up an accessor "name", which is read/write (i.e., may be used in the "new" constructor, or in separate methods that override previous values). The type is a "Str", which is of course a string.

Next, an invoice line

The next class represents one invoice line, having an item description, a quantity, and a unit price. Pretty simple. Besides these accessors, there's also the method "total" that checks that the necessary fields are there, and then returns the total of the invoice line.

Again, left is the Moose-free code, right is the Moose-scaffolded Perl.

package Invoiceline;
use strict;
use warnings;

use Carp;
use Exporter;

our @ISA    = qw(Exporter);
our @EXPORT = qw(new description qty unitprice);

sub new {
    my $class = shift;

    my $self = {};
    bless $self, $class;

    my %opt = @_;
    for my $key qw(description qty unitprice) {
	$self->{$key} = $opt{$key} if (defined $opt{$key});

sub description {
    my ($self, $description) = @_;
    $self->{description} = $description if (defined $description);

sub qty {
    my ($self, $qty) = @_;
    $self->{qty} = $qty if (defined $qty);

sub unitprice {
    my ($self, $unitprice) = @_;
    $self->{unitprice} = $unitprice if (defined $unitprice);

sub total {
    my $self = shift;
    croak 'No unitprice' unless ($self->unitprice);
    croak 'No qty'       unless ($self->qty);
    return $self->unitprice * $self->qty;

package Invoiceline;
use Moose;
use Carp;

has 'description' => (is => 'rw', isa => 'Str');
has 'qty'         => (is => 'rw', isa => 'Int');
has 'unitprice'   => (is => 'rw', isa => 'Num');

sub total {
    my $self = shift;
    croak 'No unitprice' unless ($self->unitprice);
    croak 'No qty'       unless ($self->qty);
    return $self->unitprice * $self->qty;

no Moose;
Again, the Moose scaffolding really helps shortening the code. The accessors for "description", "qty" and "unitprice" are instantiated using just three "has" statements. This really makes the code cleaner and saves typing. Regardless of whether Moose is used, the Perl package can be extended with any other methods you'd like, even coded in the standard "old-fashioned" way. That's why the method "total" is identical in both listings. The call to the Moose method "has" can have many more options, such as a default value, a function that's executed after the value changes (e.g., for range checks), how a value can be coerced from a different type, etc. Moose furthermore supports roles. See the docs for more.

The Invoice

Having done the prework, here's what an invoice is. It must have an ID, a customer, and invoice lines. I've chosen to implement the invoice lines as an array of refs to "Invoiceline" objects. There's a method "invoiceline" that adds one "Invoiceline" object to the array. Finally there's a method "display" to show the invoice on screen.

Again, left side is standard code, right side is Moose. The method "display" is identical in the two versions. Just for the fun of it, the fields for the customer and the invoice ID may only be set during construction ("Invoice->new"), but not using the method calls. This is implemented in the non-Moose code by inspecting the parameters to "new" and requiring the tags "id" and "customer". In Moose-talk this is simply done by flagging these accessors as "ro", which is of course read/only - meaning that the values can be set only during initialization (object construction).

package Invoice;
use strict;
use warnings;

use Carp;
use Exporter;

our @ISA    = qw(Exporter);
our @EXPORT = qw(new id customer invoicelines invoiceline display);

sub new {
    my $class = shift;

    my $self = {};
    bless $self, $class;

    my %opt = @_;
    for my $key qw(id customer) {
	if (defined $opt{$key}) {
	    $self->{$key} = $opt{$key};
	} else {
	    croak 'No $key option in construction';
    $self->{invoicelines} = $opt{invoicelines}
      if (defined $opt{invoicelines});

sub id {
    my ($self, $id) = @_;
    $self->{id} = $id if (defined $id);

sub customer {
    my ($self, $customer) = @_;
    $self->{customer} = $customer if (defined $customer);

sub invoicelines {
    my ($self, $invoicelines) = @_;
    $self->{invoicelines} = $invoicelines if (defined $invoicelines);

sub invoiceline {
    my ($self, $invoiceline) = @_;
    if (not defined $self->{invoicelines}) {
	$self->{invoicelines} = [ $invoiceline ];
    } else {
	push @{ $self->{invoicelines} }, $invoiceline;

sub display {
    my $self = shift;

      "                              I N V O I C E\n",
      $self->id, "\n",
      $self->customer->name, "\n",
      $self->customer->address, "\n",
      "Description                       Qty    Unit    Subtotal\n";
    my $overall_total = 0;
    for my $l (@{ $self->invoicelines}) {
	printf "  %-28s %6d   %5.2f  %10.2f\n",
	  $l->description, $l->qty, $l->unitprice, $l->total;
	$overall_total += $l->total;
    printf "\nTotal: %50.2f\n\n", $overall_total;


package Invoice;
use Moose;
use Customer;
use Invoiceline;

has 'id'	      => (is  => 'ro', isa => 'Str');
has 'customer'        => (is  => 'ro', isa => 'Customer');
has 'invoicelines'    => (is  => 'rw', isa => 'ArrayRef[Invoiceline]');

sub invoiceline {
    my ($self, $line) = @_;
    if (not $self->invoicelines) {
	$self->invoicelines( [$line] );
    } else {
	push @{ $self->invoicelines }, $line;

sub display {
    my $self = shift;

      "                              I N V O I C E\n",
      $self->id, "\n",
      $self->customer->name, "\n",
      $self->customer->address, "\n",
      "Description                       Qty    Unit    Subtotal\n";
    my $overall_total = 0;
    for my $l (@{ $self->invoicelines}) {
	printf "  %-28s %6d   %5.2f  %10.2f\n",
	  $l->description, $l->qty, $l->unitprice, $l->total;
	$overall_total += $l->total;
    printf "\nTotal: %50.2f\n\n", $overall_total;


no Moose;

The Test Script

Finally there'a a test script that instantiates two invoices and displays them. The script of course works with both Moose and non-Moose package implementations, since the accessors are identical. Just as an illustration, the second invoice construction is "chained" in the calls; as in Invoice->new(...)->invoiceline(...)->invoiceline(...)->display.
#!/usr/bin/env perl

use strict;
use warnings;

use Customer;
use Invoiceline;
use Invoice;

my $i =
  Invoice->new(id       => '2012-09-17784',
	       customer => Customer->new(name    => 'Bits and Stuff',
					 address => '1200 Main St., '.
					             'Wright, 77145 TX'));

$i->invoiceline(Invoiceline->new(description => 'Nibble',
				 qty         => 4,
				 unitprice   => 0.12));
$i->invoiceline(Invoiceline->new(description => 'High bit',
				 qty         => 3,
				 unitprice   => 0.03));
$i->invoiceline(Invoiceline->new(description => 'Low bit',
				 qty         => 1,
				 unitprice   => 0.01));
$i->invoiceline(Invoiceline->new(description => 'Byte',
				 qty         => 65536,
				 unitprice   => 0.18));

  ->new(id => '2012-09-17785',
	customer => Customer->new(name => 'Charlie\'s Cheeses',
				  address => '1415 River Rd., Alexandria, '.
				             '34557 MN'))
  ->invoiceline(Invoiceline->new(description => 'Cheddar, 1kg',
				 qty => 2,
				 unitprice => 12.50))
  ->invoiceline(Invoiceline->new(description => 'Roquefort, 100gr',
				 qty => 1,
				 unitprice => 2.35))
  ->invoiceline(Invoiceline->new(description => 'Emmenthaler, 5kg',
				 qty => 3,
				 unitprice => 49.90))


So far so good. But how fast is Moose? Unfortunately.. using Moose has a great impact. Running the non-Moose version a hundred times took me 1.6 seconds on my laptop. the Moose version ran for 27.5 seconds, so that's 17 times slower.

Here's my take on it: As a programmer, you do get a lot more when using Moose. But the performance is a serious drawback when using it for small command-line tools. However, in a once-loaded app server environment, such as in Catalyst, it's really worth while. The load time is used up just once, and the code becomes much cleaner and "safer". So, yeah, I plan on using Moose for bigger projects that run in a load-once web container; but not for the daily scripts that glue together a Unix system.

Comments or remarks as ever to Happy Perl coding!


Just a day later I received a remark and a question from Eddie:
Nice post mate. I've never heard of Moose before.
Did you benchmark Moose code inside an app-server? I'm curious if the tremendous overhead is caused by the loading part only or is it (partly) a runtime penalty?
If it is loading-overhead only it is a viable option. Otherwise I would hack a little code-generator to generate the boilerplate stuff and hand-code the functional parts. Maybe do the functional parts in another file and the generator constructs the final class. That way you can overload the boilerplate methods if so desired...

Well let's see. I took one of the above shown Invoice generation blocks and ran the following test:

  • I measured the load time
  • I measured the excution time of running the Invoice->new(...) call 100.000 times
  • I did this with the Moose-scaffolded version and with the plain Perl-OO version.
And the results are...
  1. The script load time is was 50 times longer when using Moose in this example;
  2. Instantiating a Moose-enhanced class was 2 times longer when using Moose.
So the penalty is mainly in the load time, which would mean that Moose is prefectly suitable for an app-server context. The execution which is 100% slower is I think acceptable; because:
  • Normally Perl code won't be only Moose-instantiation, there will be lots of other tasks (which diminishes the Moose-induced performance hit);
  • Usually an application will spend most of its time waiting for I/O anyway (such as a database or a webservice call), which will further mean that the Moose-hit is relatively much smaller;
  • Hardware gets faster by the day, so who cares.

2012-08-22 How do you export photos from Adobe Photoshop Elements
2012-08-21 Security hole at the Empire State Building
2012-07-15 Matrix Sunglasses
2012-07-12 Two Morgans
2012-07-12 Review of the BMW R1200RT Motorbike
2012-06-13 Passwords: maak het hackers moeilijk
2012-06-13 Mijndomein foutje
2012-06-07 YOLNT
2012-06-06 Human Origins
2012-05-23 Me on Facebook
2012-05-16 Voluntary Layoffs
2012-05-07 RBS Bike Tour
2012-04-27 Room with a view
2012-04-23 Browser cookies and Javascript revisited
2012-02-17 Schrodingers Cat
2012-02-14 KPN heeft problemen
2012-01-12 Memebase forever
2012-01-11 Strange squares
2011-12-22 TVV zuigt ezel
2011-12-08 Dilbert vs Skype
2011-11-29 The uncanny resilience of bulshytt
2011-11-23 Another silly Trojan attempt
2011-10-29 ACTA is coming our way
2011-10-28 Burgernet in the Netherlands
2011-10-27 Facepalm art
2011-10-26 Do not drag this image
2011-10-22 Off The Grid Challenge
2011-10-12 PI like a boss
2011-10-07 Once upon a time
2011-07-13 Dutch eticket system for trains
2011-07-12 Is Hell exothermic or endothermic
2011-04-27 Optical Illusions
2011-04-19 Odd lyrics
2011-04-16 Band Revival at MON
2011-03-13 Protests in the Middle East and you
2011-03-10 Mac OSX Hotkey for locking your system
2011-02-12 dnspb 0.06 is out
2011-02-08 Would I buy this fridge
2011-02-06 InstaYouth
2011-02-05 The Thinker is back
2011-01-17 Math challenge
2011-01-11 Zero tolerance and zero intelligence
2011-01-05 My interest income in 1991
2011-01-01 Your horoscope by Eddie
2010-12-22 New York City Tours might be half price for you
2010-12-20 Weather Forecast
2010-12-14 World Economy Collapse explained in 3 minutes
2010-12-13 The Salvation Army and its choice of toys
2010-12-08 Elizabeth thinks highly of me
2010-12-06 Should I trust my government with my data
2010-12-05 Announcing dnspb
2010-12-03 Realistic piechart
2010-11-26 Crossroads 2.71 is out
2010-11-24 8 bit Starwars
2010-11-17 Six to eight black men
2010-11-16 Canada wants backdoors and data and everything
2010-11-11 Autumn storm over the Netherlands
2010-10-08 USA wants backdoors to everything
2010-10-05 Sudoku solver in Perl
2010-10-02 Finally wrote up a Syscheck page
2010-09-28 Neon sign fail
2010-09-27 The Renault Eco Team
2010-09-23 Crossroads 2.68 is out
2010-09-20 How to suppress Flash cookies
2010-09-15 Meanwhile on Facebook
2010-09-09 The Yes Men Fix The World
2010-09-07 ed is not dead
2010-08-26 Installing Perl modules in a non root environment
2010-08-22 Magic self leviation
2010-08-20 Google Chrome does not support offline Gmail
2010-08-19 The number 48
2010-08-12 Welsh trout mini HOWTO
2010-08-04 Fooling a NetCache proxy into fetching forbidden files
2010-07-30 The world will end on May 21, 2011
2010-07-28 Hiding or showing a textbox with image animation using JQuery
2010-07-27 Manipulating browser cookies using Javascript
2010-07-25 Survival of the fittest book
2010-07-23 Pastafarians in Spain
2010-07-22 You have two sheep
2010-07-09 Highway bank fire
2010-07-08 Setting up a remote git repository
2010-07-06 Bye bye trusted old Macbook
2010-06-28 John Cleese on Football
2010-06-23 ABN Amro and the Pathetic Customer Service Dept.
2010-06-22 Wally does not like criticism
2010-06-14 Soccermatch Netherlands vs Denmark
2010-06-13 Lazy Cat
2010-06-08 Reading public Buzz using the Google API
2010-06-07 A Personal Letter from Steve Martin
2010-06-05 Sushi Saturday
2010-06-04 Suppressing the Enter key with Javascript
2010-05-31 Temporal spacial anomaly on the Dutch highway
2010-05-23 Greenhost will not log your traffic
2010-05-10 Jarlsberg Webapp Exploits
2010-05-04 A Thought Experiment
2010-05-03 SafeEdit information updated
2010-05-01 Microproxy now supports ftp
2010-04-30 What could get Data angry
2010-04-29 Lego Mindstorm solving the Rubik Cube
2010-04-28 Crossroads 2.65 is out
2010-04-17 Goggomobil in its natural habitat
2010-04-14 Bacon Time
2010-04-11 104 More friends to connect with
2010-04-10 Bacteria infested radio reporter
2010-04-07 The Kubat STAR
2010-03-30 Homework Essay
2010-03-29 C++ mutexes again
2010-03-20 Weird Eyechart
2010-03-15 Microproxy 1.01
2010-03-05 Microproxy
2010-03-03 Sven Kramer and the wrong lane
2010-02-26 Endearing Babe Magnet
2010-02-17 Speed of light measured using chocolate and a microwave
2010-02-17 Never again expires after 65 years
2010-02-16 encfs on the Mac
2010-02-15 and sexual predators
2010-02-10 Funny textbook
2010-02-09 DNS failing after sleep wake cycle
2010-02-06 Blast from the past
2010-01-28 Simple and straight Perl HTTP::Proxy
2010-01-15 Avatar the Movie
2010-01-08 Slightly NSFW Linux Ad
2010-01-07 WTF
2010-01-05 Stop Software Patents in the EU
2009-12-05 HammerServer 1.02
2009-11-28 Perls Automagical Autoloading
2009-10-07 Office Poster
2009-10-06 The nr 1 Nerdjoke
2009-10-04 WoW Startscript for my Mac
2009-09-27 HammerServer section is online
2009-09-26 The BING HQ
2009-09-26 Digging a WOW Tunnel
2009-06-29 Wee Todd
2009-06-23 The On Off Switch Revisited
2009-06-22 Meatspace
2009-05-30 My old houses
2009-05-11 LOLcats are funny
2009-05-11 Civic Duty WIN
2009-05-10 Vote for the baby, Sky Radio promo FAIL
2009-05-05 My secure data center
2009-02-15 My Valentine is sending me a dot exe
2009-02-05 MacPorts trash: .mp_123456 savefiles cleaning
2009-02-01 Truecrypt 6 on Linux and the ext3 filesystem
2009-01-28 www versus
2009-01-27 Songsmith and The Police
2009-01-25 My own Ministery of Silly Walks
2009-01-09 CoolIris Mini HOWTO
2008-11-04 UDP and DNS balancing
2008-11-02 Life in graphs
2008-11-01 Skeined yet?
2008-10-30 New Crossroads on the horizon
2008-10-28 Thread safe or not
2008-10-15 WOW patch 3 on a case sensitive MacOSX filesystem
2008-10-15 Surprising C++ optimizations
2008-10-14 Weird system message
2008-10-08 Data mining against terrorism does not work
2008-09-16 Crossroads at the top of
2008-09-09 Stupid spammers at Computable
2008-09-06 Spam prevention with Postfix and Postgrey
2008-09-03 The Gnomish Flying Machine
2008-08-27 Bank customer data on eBay
2008-08-26 Mutexes in C++ Threads
2008-08-22 4M dataloss in the UK last year
2008-08-21 Dropping spam with Postfix and Spamassassin
2008-08-18 Bayes and the War on Photography
2008-08-13 Good marital advice
2008-08-12 Squid proxy for personal usage
2008-08-11 Posix threads in C++
2008-08-09 Crossroads mailing list
2008-08-08 Crossroads 2.00 is out
2008-08-01 Fail Pics
2008-07-14 The Fish Dance
2008-07-01 Big Bother and Massive Data Storage
2008-06-30 MMV One of omitted Unix tools
2008-06-08 Even anonymous breadcrumbs can give you away
2008-05-29 Crossroads in Argentina
2008-05-20 The Party at the Company Outing
2008-05-19 Crossroads 1.80 is out
2008-05-18 Where does technical innovation really come from
2008-05-16 Corporate bs generator
2008-05-15 Even the Vatican has to adapt
2008-05-12 Big Brother is watching your dog
2008-05-09 666 all over the place
2008-04-17 Security and privacy are incompatible
2008-04-16 The Hallmark E Card
2008-04-15 Crosroads Solaris port is out
2008-04-04 Identity theft can cost you dearly
2008-04-03 Crossroads can already do that
2008-03-31 A dagerous safari
2008-03-28 Why some Java J2EE projects are inefficient
2008-03-26 The Hummingbird
2008-03-25 The Easter delusion
2008-03-18 McAfee detects mass hack of 200.000 webpages
2008-03-17 More predictive statistics
2008-03-10 Backwards conclusions even on Slashdot
2008-02-18 A fractal photograph
2008-02-15 Kaprekar revisited
2008-02-14 Kaprekar numbers
2008-02-12 A tale of the criminal ineptitude
2008-02-10 Irritating Selfregistered users in PHPBB
2008-02-08 B2B Spam in the Netherlands
2008-02-06 Surprising iSight Capture
2008-02-05 Breadcrumbs at
2008-01-29 iSight Capture Utility
2008-01-28 The Male Brain
2008-01-26 Searching for the next Uri Geller
2008-01-24 Opt in for b2b spam
2008-01-14 Bokito Revisited
2008-01-13 Top Crossroads User
2008-01-12 World of Warcraft Dancing
2008-01-12 Justice dispensed better late than never
2008-01-11 Jeremy Clarkson and Identity Theft
2008-01-10 Terrorism in the Netherlands
2007-12-07 The mind and bodysnatchers are among us
2007-12-05 Bruce Schneier and Hildo
2007-12-04 Bye bye, good Christian soul
2007-12-03 Confusing mail message
2007-11-30 Medion MD 85276 reviewed
2007-11-29 Recent cases of data exposure
2007-11-20 Bayes bites
2007-11-19 Japan starts fingerprinting foreigners
2007-11-14 Privacy, Yahoo and the Strange World
2007-11-14 Privacy, Fall through algorithms, and Securing data
2007-11-07 European airlines to retain data
2007-11-03 BloggEd
2007-10-30 Wilders and
2007-10-28 The goldplated Mac
2007-10-26 More morons
2007-10-26 Dilbert nails it again
2007-10-23 Rough yet funny
2007-10-05 Another silly Trojan mail
2007-10-01 So ugly it is beautiful
2007-09-28 Here is a nickel kid
2007-09-23 Spy Shredder
2007-08-29 Web svn view 1.08
2007-08-24 Caught in THE Process
2007-08-21 Stupid Trojan attack
2007-08-21 Back in 1994
2007-08-20 A girly iPod
2007-08-17 Crossroads for RDP connections
2007-08-15 Firewall art
2007-08-14 jpeginfo
2007-08-13 Good People
2007-08-07 The Real Crossroads
2007-07-30 BBC Documentaries in the Netherlands
2007-07-12 No problems with Crossroads so far
2007-07-11 Politically correct ad nauseam
2007-07-02 Waka Waka Poem
2007-07-02 Voyage of the rubber ducks
2007-06-28 The On Off Switch
2007-06-27 No free lunch
2007-06-25 Crossroads web interface
2007-06-25 Blinkenlights
2007-06-21 There is no silver bullet
2007-06-18 Motto of the week
2007-06-18 Do not feed the troll
2007-06-17 Which programming language are you
2007-06-13 Crossroads support request
2007-06-12 Bokito glasses
2007-06-07 Apache mod_proxy balancer description
2007-06-05 A ticketnumber is not support
2007-06-05 403 Hammertime
2007-06-04 Playground Fun
2007-05-24 Ascii man
2007-05-07 Cannot find the damn server
2007-05-02 The BFG200
2007-04-27 Crossroads Top User
2007-03-30 Crossroads Usage
2007-03-25 The guy with the dark motorhelmet
2007-03-22 The Process and The Result
2007-03-21 Quotes attributed to Jos
2007-03-20 A really nice comment about Crossroads
2007-03-18 Kubat in the air