Chris on Software

Thanks to Paul Chote (github/pchote) we’ve got support for the original Command & Conquer being added to OpenRA as well. Here’s an early screenshot for the Nod side. Most things work, except for Ore to Tiberium conversion:

An odd combination, but the beer is rather good.

My wife got me flying lessons for Christmas; I had my first flight today. Flew (more or less) one loop of the traffic pattern for Feilding aerodrome, with a few extra turns to get used to the controls.

Me with ZK-TOD, a Cessna 152, before doing the preflight checklist.

Taxiing out to the runway. It’s… interesting, driving with your feet.

Nice takeoff, eastward toward the ranges.
Can’t see much because of the cloud.

I definitely didn’t taxi onto the grass a bit here. Hmmn.

… And back to where we started.

Was awesome, I’m definitely hooked. Back again on Saturday for another lesson.

Here’s a capture from a hacked OpenRA build:

I’ve been happily using Git for all my personal projects for the last couple of months, and everything is great – except for the performance of Github for pulling and pushing. I’ll outline here the steps I took to fix it.

First, I noticed that only the authenticated access to Github is pathetically slow. Pulling from the public URI is fast. I tried exploiting this by adding a read-only copy of each remote:

$ git remote add origin-ro -f git://github.com/chrisforbes/OpenRA.git

Then I just use the appropriate remote for pulls and pushes:

$ git pull origin-ro master                 # grab upstream changes
$ git push origin master                    # push changes back

Now this works, but it has some undesirable side-effects. For example, one of my projects is fairly active, with others contributing to the upstream Github repo. This is normally fine, except that git doesn’t know the two remotes are actually the same repo (how could it?) so they get their heads out of sync. I find myself having to do this several times a day to get a sane view of upstream:

$ git fetch origin-ro

That’s not ideal, so I did a bit of digging around, and noticed interesting output from the git-remote command:

$ git remote –v
... snip ...
origin  git@github.com:chrisforbes/OpenRA.git (fetch)
origin  git@github.com:chrisforbes/OpenRA.git (push)

This seems to suggest that you can set different fetch & push URLs. Yet the git-remote manual page says nothing about this – in fact, it’s pretty clear that there are two config options that control this stuff. Unhelpful.

It turns out that if you read the git-push man page, or the git-config man page (which is useful, but incredibly long), there’s another option: remote.<remote-name>.pushurl. Time to fix this mess:

$ git config remote.origin.url git://github.com/chrisforbes/OpenRA.git
$ git config remote.origin.pushurl git@github.com:chrisforbes/OpenRA.git
$ git remote rm origin-ro

... repeat for every other remote i have ...

So we’ve switched the fetch URL over to use anonymous access, and set pushurl to something that allows writing. Because it’s all within the same remote now, git (esp gitk, which is very dumb!) doesn’t get confused.

Hopefully this is useful to someone

While we conveniently don’t often hear of opinions other than the shrill mainstream environmental activist’s (and now politician’s) cry of “oh crap, the climate is changing and it’s our fault for, uh, breathing and driving cars and stuff, so, uh, pay this new tax” it should be plainly obvious that the Earth’s climate has not historically been stable – long before the human population was anywhere near large enough to have any impact whatsoever, no matter how outlandish a model of the impact of human CO2 production you might use.

There have been considerably warmer times, and there have been considerably cooler times, and these variations are clearly perfectly natural. This is true independent of whether the current round of political scaremongering is backed up by correct theory or not.

So my question, to which I have never heard an adequate answer from anyone is this:

Given that the temperature record shows substantial ongoing changes in the absence of significant human tampering, what is the goal? If we were to jump wholeheartedly on board the anti-climate-change bandwagon, what rate of residual change after removing our contributions is an acceptable natural level?”

Read the rest of this entry »

Rosanna has been very busy making more knitted things:

Castle

You’ve got to have someone to live in the castle. I have step-by-step construction photos for this one, which I’ll post later.

Parrot (and Rosanna, and a pile of dishes.)

Various penguins and a chunk of ice. Apparently this will become a penguin Christmas scene, so I’ll post that when it’s done too.

Baby Kiwi

Here’s some old favorites, in a better photo:

Last time we built a very simple web server that can serve up errors and static files off the disk. Now we’re going to add more capabilities. First, redirecting the client from one URI to another:

Routes = new []
{
    Server.ServeRedirect("/index.html", "/static/index.html" ),

Read the rest of this entry »

First, for those hardcore folks: We’re not going to be implementing the nitty-gritty details of HTTP today. I have done it once, in C, for an embedded system, and I have no great desire to repeat the experience. So we’ll be using HttpListener to do the heavy lifting for us. Blatant cheating, I know, but it will also allow us to cover some interesting behavior, rather than getting bogged down in minutiae.

First, let’s have an example of where we want to be going. To start serving stuff, all we should have to do is create a server object, specify what we want to serve, and start accepting connections:

Read the rest of this entry »