It's a pretty simple affair, largely based upon this instructional video. The pull-up bar runs perpendicular to a pair of rafters that are 4 feet apart, hanging a few inches below the bottom of the rafters. In my garage, the rafters are 2x6, which seem to be plenty sturdy enough even when I kip & do muscle-ups over the bar.

The materials I used for the bar:

• A 48" long, 1" diameter pipe
• Two 12" long 2x6s
• Two 6" long 2x6s
• Six 4" long 3/8" bolts
• Six 3/8" nuts
• Twelve flat washers
• Eight 2.5" long wood screws
• Construction adhesive

The only prep beyond cutting the wood is drilling the holes for the bar in the larger 2x6 pieces. Note that a 1" diameter bar has a 1" interior diameter, so you need a larger drill bit than 1"; I used a 1¼" bit which was still slightly small, but worked with a bit of extra drill action. Once the bar holes are drilled, I made the holes for the 3/8" bolts on the opposite half of the 2x6, and corresponding holes in the rafters where the bar was to be mounted. My standard procedure for woodworking is to supplement my lackluster skill with adhesive, so I applied some construction adhesive with my caulk gun between the 2x6 and the rafter and then bolted it in place.

With the supports bolted in place, I slipped the bar itself through the holes and quickly discovered the need for something more. The bar itself is 48 inches long, and the space between my rafters is also 48 inches. Since I put the supports inside a pair of rafters, the bar was nicely flush with the outside of the supports, but this also meant it would only take a couple of inches of lateral movement for it to fall out. The solution is to cap fashion caps using some more 2x6 and secure it with wood screws.

To this end, I have created a simple framework for managing child/worker multiprocessing in PHP. Like other high-level interpreted languages, the most straightforward way to spin things up is using fork(2) to create new processes. While not as Hardcore and Awesome as the lightweight threads that other languages provide, OS-level process creation isn't a huge hindrance if you code for it: make the child processes long running so as to mitigate the startup cost.

The framework is part of the Team Lazer Beez Open Source project--you can find it in the utility package. The entire thing is simple enough to fit in a single class, gosUtility_Parallel, the basics of which can be credited to chaos' post on Stack Overflow.

Using the library is simple--extend gosUtility_Parallel and override the doWorkChildImpl() method:

// Include the Genius config file
require_once dirname(dirname(__FILE__)) .'/Core/testConfig.inc.php';

class Minimal extends gosUtility_Parallel {
    protected function doWorkChildImpl() {
        gosUtility_Parallel::$logger->debug($this->workerID . " started");
        usleep(2000000);

        gosUtility_Parallel::$logger->debug($this->workerID . " doing work");
        usleep(2000000);

        gosUtility_Parallel::$logger->info($this->workerID . " finishing");
        exit(1);
        return;
    }
}

This class creates simple workers that print a couple of debug messages with some sleeping in between, and then announce that they are done working. Now you can instantiate the class with a single argument: the number of children to run. gosUtility_Parallel will take care of all the details.

// Make with the go
$minimal = new Minimal(2);
$minimal->go();

If children exit with a non-zero status, the parent will spin up a replacement. The parent will continue to run until all children have exited normally, or it gets INT (say, ctrl+c) or TERM (the default signal sent by kill(1)), in which case it will pass that signal on to the children, ensure they shut down, and then end itself. gosUtility_Parallel provides ample logging information; running the above produces the following output:

INFO - Started worker 0 (pid 42093)
DEBUG - 0 started
INFO - Started worker 1 (pid 42094)
DEBUG - 1 started
DEBUG - 0 doing work
DEBUG - Checking worker 0 (pid 42093)
DEBUG - Checking worker 1 (pid 42094)
DEBUG - 1 doing work
INFO - 0 finishing
INFO - 1 finishing
DEBUG - Checking worker 0 (pid 42093)
INFO - Worker 0 (pid 42093) exited normally
DEBUG - Checking worker 1 (pid 42094)
INFO - Worker 1 (pid 42094) exited normally

gosUtility_Parallel provides a number of overrideable methods whose names explain their purpose: parentSetup(), parentCleanup(), and childCleanup(). Children can also get their $workerID and the $maxWorkers number making processing based upon modular division trivial. The example parallel class in the distribution demonstrates some of these features:

// Include the Genius config file
require_once dirname(dirname(__FILE__)) .'/Core/testConfig.inc.php';

class Par extends gosUtility_Parallel {
    public function __construct($maxWorkers) {
        parent::__construct($maxWorkers);

        // Redefine the logger
        gosUtility_Parallel::$logger = Log5PHP_Manager::getLogger('gosParallel.Par');
    }

    protected function doWorkChildImpl() {
        gosUtility_Parallel::$logger->debug($this->workerID . " started");

        // Run until told not to
        global $run;
        while ($run) {
            gosUtility_Parallel::$logger->debug($this->workerID . " doing work.");
            usleep(2000000);
            if ($this->workerID == 0 && rand(0,10) == 7) {
                gosUtility_Parallel::$logger->info($this->workerID . " returning");
                return;
            }
        }
    }

    protected function parentCleanup() {
        gosUtility_Parallel::$logger->debug("Parent cleaning up");
    }

    protected function childCleanup() {
        gosUtility_Parallel::$logger->debug($this->workerID . " cleaning up");
    }
}

The example above runs out-of-the-box (provided your PHP was built with --enable-pcntl, so I encourage you to download the source and take it for a test drive.

Incidently, if you're in the Perl world you can just use Parallel::ForkManager and be on your way.

There are a number of good tutorials for setting up OpenVPN, and the following instructions will mostly mirror those. First, install the requisite packages:

caligula:~$ sudo aptitude install openvpn

Then, setup a place to generate the requisite keys:

    caligula:~$ mkdir tmp/vpn && cd vpn
    caligula:~/tmp/vpn$ cp -r /usr/share/doc/openvpn/examples/easy-rsa/2.0/* .

At this point, many tutorials (the above mentioned ones included) say that you should run ./init-config, which doesn't exist in recent version OpenVPN. With the scripts for generating keys in place, open up vars and edit the stuff at the bottom, which should be pretty straightforward:

    export KEY_COUNTRY="US"
    export KEY_PROVINCE="NY"
    export KEY_CITY="Rochester"
    export KEY_ORG="Dinomite-Net"
    export KEY_EMAIL="drew@dinomite.net"

The vars file just sets up a bunch of environment variables, so you'll want to source it and then build the certificate authority:

    caligula:~/tmp/vpn$ source vars
    caligula:~/tmp/vpn$ ./clean-all
    caligula:~/tmp/vpn$ ./build-ca

Building the certificate authority involves a few questions, for most of which the defaults defined from vars are all you need. Next, build the keys for the server and client (I name my computers after Roman emperors):

    caligula:~/tmp/vpn$ ./build-key-server caligula
    caligula:~/tmp/vpn$ ./build-key vespasian
    caligula:~/tmp/vpn$ ./build-dh

With all that done, you can copy the appropriate key files over to the client, in my case vespasian. Since I already had tunnelblick on that machine, I put the files directly where they needed to go:

caligula:~/tmp/vpn$ cd keys
caligula:~/tmp/vpn/keys$ scp vespasian.crt vespasian.key \
    ca.crt vespasian:~/Library/Application Support/Tunnelblick/Configurations/

Two steps left. First, make the client configuration file. For tunnelblick, this goes in the same directory as above, and you can name it whatever you want:

    vespasian:~$ cat Library/Application Support/Tunnelblick/Configurations/client.conf
    client
    dev tun
    proto udp
    remote caligula.dinomite.net 1194
    resolv-retry infinite
    nobind
    persist-key
    persist-tun
    ca ca.crt
    cert vespasian.crt
    key vespasian.key
    comp-lzo
    verb 3

There are plenty of other sites that will explain what all of those options mean, so I won't go over it here. The important things to change from above are the remote and the names for the cert and key. Now on to the server config and the files that it needs:

    caligula:~/tmp/vpn/keys$ cp dh1024.pem caligula.key caligula.crt /etc/openvpn/
    caligula:~/tmp/vpn/keys$ cat /etc/openvpn/server.conf
    server 10.7.7.0 255.255.255.0
    push "redirect-gateway"

    dev tun0
    proto udp
    keepalive 10 120
    comp-lzo
    dh /etc/openvpn/dh1024.pem
    ca /etc/openvpn/ca.crt
    cert /etc/openvpn/caligula.dinomite.net.crt
    key /etc/openvpn/caligula.dinomite.net.key

    status /var/log/openvpn-status.log
    verb 3

The secret sauce in that config is push "redirect-gateway" which is what tells the client to route all of its traffic through the tunnel to the server. To make this work, the server needs to be set up to do NAT:

    caligula:~/tmp/vpn/keys$ echo "1" > /proc/sys/net/ipv4/ip_forward
    caligula:~/tmp/vpn/keys$ iptables -t nat -A POSTROUTING -s 10.7.7.0/24 -o eth0 -j MASQUERADE

That's all there is to it! Just restart the server (sudo /etc/init.d/openvpn restart), connect, and all your traffic is now safely encrypted to the server.

EBC Greenstuff

An awesome street pad, thanks to producing much less dust than stock. I drove these pads at my very first HPDE with the National Capital Chapter of the BMW CCA; the track is not their forte. By the end of the second day, I had burned through 3/4 of the pads, and the car was putting out clouds of smoke braking into turn 1 on Summit Point's main circuit. Unsurprisingly, this was accompanied by significant fade.

Like stock pads, these will work for your first track experience if you are conservative, but I wouldn't recommend it. Thanks to their low dust, EBC Green Stuff work great for street pads and even the occasional autocross.

Hawk High Performance Street (HPS)

The HPS are biled as a stock-replacement pad and I would agree with that. They dust a bit less than BMW OEM pads, and provide a little bit more fade resistance. For track use, the HPS is much like stock or the EBC Greenstuff mentioned above--they'll work if you're new & conservative or slow.

Axxis Ultimate (ULT)

These are quite similar to the HPS--less dust than stock, good feel even when stone cold, and a bit more heat handling capability than stock. They work great for street driving and autocrossing, but are only good for limited (read: slower) track use.

Hawk High Performance Plus (HP+)

The HP+ are a good compromise between track and street pads. I recently used them for a fade-free weekend at Thunderhill with ambient temperature of 70-80F. Unlike a full-on track pad that is downright scary on the street, the HP+ is decidedly OK on the street. The first stop of a drive (or after not using them on the highway for a few minutes) will be a bit longer than stock pads, but not the Flintstones feeling of track pads.

Hawk Blue

I am lazy, so I put my pads on at home before driving to the track, so I got to experience these on the street. To begin with, the first stop from neighborhood speeds takes about twice the distance you expect, and the initial bit is nonexistent. After a couple more low speed stops, the brakes have enough heat to work just fine, but they still squeal as though you are murdering cats with each brake application.

On the track, the Hawk Blue is an awesome pad. Being a true track pad it takes some heat before they really work, as described above. Just like you need to get your tires and brain up to temperature, with a track pad you need some heat in the brakes before they will do what you expect. You should be driving judiciously on your out lap anyway, so this ought not be a problem. The wear on these is much better than any of the aforementioned pads--a day at Laguna Seca burned less than one quarter. If you have been going to the track for a while, or if you've gotten fast enough to begin feeling fade in your existing brake setup, get some track pads.