First, for connectivity between private LANs across the Internet, Hamachi works very well (and is free for non-commercial use). It’s supported on Windows and OS X, and in beta for Linux and Windows Mobile. Just install the client on each machine, and you’ll have a virtual IP address that you can use to securely tunnel over the Internet to other machines in your mesh using any application. I created a LogMeIn account to use Managed mode which (obviously) makes management easier, but Unmanaged mode works as well.

Next, you can use rsync to efficiently copy and synchronize files through the Hamachi tunnel. It’s usually already installed on Linux and OS X, and can be easily installed on Windows using the Cygwin installer.

While Hamachi makes it easy to browse Windows shares (assuming you’re running Windows) via the tunnel, or even rsync them using a UNC path, the SMB protocol is glacially slow. Therefore, you’ll want to set up the rsync daemon on the machine containing your authoritative version. (While rsync can easily provide two-way synchronization, it is much less risky and mentally taxing to treat one copy as authoritative and access it using a read-only rsync share.) To configure the daemon, you’ll need to create a file called /etc/rsyncd.conf that specifies global and per-library options. On Windows, to share a music library in M:\Music, the file would look like this:

use chroot = false
strict modes = false

[Music]
path = /cygdrive/M/Music
read only = true

Then you can fire up the rsync daemon simply by running rsync --daemon from a shell, command prompt, Run dialog (Windows+R), etc. rsync won’t output anything, but you can verify in your process/task manager that it’s running. If you want the rsync daemon to run automatically as a Windows service, that can be done using cygrunsrv, but you’ll have to refer elsewhere for instructions.

Finally, to actually sync the library to a client, you’ll need to enter a slightly gnarly rsync command (which the difficulty of remembering inspired this blog post) on the client:

rsync -rtOh --chmod=ugo=rwX --ignore-existing --delete --progress rsync://<server IP from Hamachi client>/Music/* /cygdrive/c/Music

This command will copy the everything in the Music module (defined above as M:\Music) to C:\Music, deleting anything in C:\Music that doesn’t exist in M:\Music. Refer to the rsync man page for details on these options and others, but here’s a brief explanation:

• -r, –recursive: recurse into directories
• -t, –times: preserve modification times (to aid future synchronization)
• -O, –omit-dir-times: omit directories from –times
• -h, –human-readable: output numbers in a human-readable format (we’re humans, right?)
• –chmod=ugo=rwX: give new files the destination-default permissions (otherwise they’ll end up with screwy permissions)
• –ignore-existing: skip updating files that already exist on the destination (unless you want things like MP3 tag changes to trigger lots of delta transfers)
• –delete: delete extraneous files from the receiving side (to avoid accumulating duplicates when files are renamed on the sender)
• –progress: print information showing the progress of the transfer (since it will probably take a long time to sync your whole media library)

Note: For your first attempt, you’ll probably want to also include the -n option, which executes a dry-run, so you don’t accidentally end up deleting files you didn’t intend to.

On the upstream server, go to where you want the repository to be located and create a bare, shared repository:

$ cd /var/git
$ git init --bare --shared myrepo.git

Then on your local machine, simply push the local repository up to the new shared repository with the -u option:

$ git push -u ssh://myuser@myserver/var/git/myrepo.git master

The -u option is short for --set-upstream. From the git-push man page:

For every branch that is up to date or successfully pushed, add upstream (tracking) reference, used by argument-less git-pull(1) and other commands.

Now with just two Git commands, your local repository acts just like you’d cloned it from your new shared repository.

Note: If you have a group of users that you want to be able to modify the repository, ensure that your top-level git directory is owned by that group and the group sticky bit is set in the permissions. For example:

$ chgrp -R git /var/git
$ chmod -R g+w /var/git
$ chmod g+s /var/git
$ ls -ld /var/git
drwxrwsrwx 22 git git 4.0K Jul 16 12:00 /var/git

use strict;
chomp;
print '"';
my $prev_esc = 0;
print map
    {
        if (ord $_ > 0x7f) {
            $prev_esc = 1;
            sprintf('\\x%lx', ord $_);
        } else {
            my $need_break = $prev_esc && /[0-9A-Fa-f]/;
            $prev_esc = 0;
            ($need_break ? '" "' : '') . $_;
        }
    }
    split('', $_);
print '"' . "\n";

Run it with the Perl -n option, and it will output an escaped string literal for each line input:

$perl -n utf8esc.pl
Grüße aus Bärenhöfe
"Gr\xc3\xbc\xc3\x9f" "e aus B\xc3\xa4renh\xc3\xb6" "fe"

Hit Ctrl-D on a blank line to exit.

Unfortunately, C/C++ seems to have the strange rule that all hex characters following a “\x” apply to that escape sequence, even though the maximum value allowed is 0xff. Therefore it is necessary to break the string into separate segments.

First, running bootstrap.bat appears to fail:

Building Boost.Jam build engine

Also, you can file an issue at http://svn.boost.org
Please attach bjam.log in that case.

Actually, it’s not failing to build, it’s just trying to copy the executable from the wrong path. All you need to do is copy tools\jam\src\bin.ntx86_64\bjam.exe to the top-level Boost directory.

Next, you need to install any of the optional libraries you want to support. For Python support, you can install the Windows AMD64 MSI Installer, and then add the install directory (C:\Python26 by default) to your PATH. For Graphviz parsing support, download and unzip Expat 2.0.1 and my VS 2008 x64 project files, then use Batch Build in VS 2008 to build the x64 targets. You’ll also need to rename the Expat library reference in Boost’s libs\graph\build\Jamfile.v2 from “expat” to “libexpat”.

Finally, run the following commands to build Debug and Release DLLs, setting the Expat paths appropriately and the -j option to the number of processor cores you have:

set EXPAT_INCLUDE=C:\expat-2.0.1\lib

set EXPAT_LIBPATH=C:\expat-2.0.1\win64\bin\Release
bjam -j3 --stagedir=stage64 --without-mpi toolset=msvc address-model=64 variant=release link=shared threading=multi runtime-link=shared stage > build-shared-multi-release64.log

With any luck, in about 5-15 minutes, you’ll have a set of DLLs and import libraries in stage64/lib. The build generates lots of output and warnings, which is the reason for redirecting the output to a file, but you’ll want to check the beginning and end of each log to make sure it built everything you expected.

After reinstalling, the userinit.exe crash went away, but then a new problem surfaced that has plagued me constantly until today: Windows Update fails on all updates. Back when the problem first occurred, I could find no solution that mentioned the particular problem, which surfaced as error 80246002 or “AUClnt FATAL: Error: 0×80004002. wuauclt handler: failed to spawn COM server” in C:\WINDOWS\WindowsUpdate.log. At long last, thanks to this page, I found the solution, KB943144, posted October 26, 2007. The short answer:

net stop wuauserv
regsvr32 %windir%\system32\wups2.dll
net start wuauserv

myFairTunes on SourceForge

My reference material on the subject was an article Chuck provided, Callbacks in C++ Using Template Functors. I felt that while it’s true that all of the functor alternatives shown in the article are obviously undesirable according to the criteria listed (and perhaps other more basic criteria, such as code readability), it doesn’t really seem to show an example of the interface-oriented (i.e. pure virtual class) model, which I believe is the purest way to solve the problem. (By pure, I mean satisfying criteria such as being object-oriented, type-safe, and non-coupled, yet not relying on void* casts and template wizardry.) Here is the example that I feel was omitted:

class Notifiable
{
public:
    virtual void notify() = 0;
}

class Button
{
public:
    void click() { if (m_pnOnClick) m_pnOnClick->notify(); }
    void onClick(Notifiable* pn) { m_pnOnClick = pn; }
private:
    Notifiable* m_pnOnClick;
}

class CDPlayer
{
public:
    void play();
    void stop();
}

class CDPlayNotifiable : public Notifiable
{
public:
    CDPlayNotifiable(CDPlayer* cdp) : m_cdp(cdp) { }
    virtual void notify() { m_cdp->play(); }
private:
    CDPlayer* m_cdp;
}

class CDStopNotifiable : public Notifiable
{
public:
    CDStopNotifiable(CDPlayer* cdp) : m_cdp(cdp) { }
    virtual void notify() { m_cdp->stop(); }
private:
    CDPlayer* m_cdp;
}

void main()
{
    CDPlayer cdp;
    CDPlayNotifiable pn(&cdp);
    CDStopNotifiable sn(&cdp);
    Button playButton;
    playButton.onClick(&pn);
    Button stopButton;
    stopButton.onClick(&sn);
    // ...
}

I believe this satisfies all but one of the “Criteria for a Good Callback Mechanism” mentioned in the article: object-oriented, type-safe, non-coupling, non-type-intrusive, and flexible. The remaining criterion, being “generic”, is of questionable validity. Obviously it’s desirable not to require the user to write repetitive support code, but I think there’s some value to explicitly defining interfaces and being able to write custom binding code. Consider, for instance, how most UI frameworks include an argument on their events that identifies the sending object. If the functor of the Button class in the article included this argument, you could no longer directly bind it directly to CDPlayer::play().

However, the code above sucks in C++ for two reasons: 1) There’s no shorthand way to provide implementations of Notifiable. (Anonymous classes in Java are great for this.) 2) Managing the lifetime of the Notifiable objects is difficult. (Again, with GC in Java, this is not an issue.) In my example, I used pointers, which necessitates ensuring that the Notifiable objects exist at least as long as the Buttons referencing them. In the functor article, this is accomplished by the functors being held by value. This makes sense for functors, which are known to be small and non-polymorphic and to implement a default constructor and operator=(). Objects implementing Notifiable may or may not be small, but more importantly, they are polymorphic and therefore cannot be held by value.

Given these difficulties, functors do seem to be a reasonable mechanism for handling callbacks in C++. I’m curious whether the memcpy() on the pointer-to-member-function in FunctorBase is kosher with regard to the C++ standard, but even if it’s not, it’s the sort of thing that always tends to work anyway.

BTW, in Java, the above code directly translates to this, which seems pretty much ideal to me:

interface Notifiable
{
    void notify();
}

class Button
{
    public void click() { if (m_onClick != null) m_onClick.notify(); }
    public void onClick(Notifiable n) { m_onClick = n; }

    private Notifiable m_onClick;
}

class CDPlayer
{
    public void play();
    public void stop();
}

void main()
{
    final CDPlayer cdp = new CDPlayer();
    Button playButton = new Button();
    playButton.onClick(new Notifiable() { public void notify() { cdp.play(); } });
    Button stopButton = new Button();
    stopButton.onClick(new Notifiable() { public void notify() { cdp.stop(); } });
    // ...
}

“It really didn’t seem like Vera was justified as a separate language,” Robinson said. “It had no tools and no libraries, it had a lot of bugs, and it ran pretty slow.” Another issue was limited reporting capabilities for functional coverage. “What took us a couple of weeks in Vera took a day in Java,” Robinson said.

Oh well, I guess that is how I feel about Vera.

I took interest in this poll because one of the nominees, Florian Müller, is the founder of NoSoftwarePatents.com, which is a cause very important to me. In addition to recognizing his efforts, a win for Müller would also do much to promote the cause. Because the poll requires voting in all 10 different areas, I found the NoSoftwarePatents.com voting guide helpful.