Ok, so I'm trying to get our team moved off a "home grown" version control system that really sucks balls to something a little less buggy (ie. doesn't core dump if you have an apostrophe in a commit message) and a little faster (takes less than 5 minutes to check in a dozen files). And no, I'm not exaggerating. It really is that bad ( Read more... )

I've spent quite a bit of time the last week trying to decode some ancient and rotting ECS BASIC programs that were recorded on cassettes back in the 80s. Cassette tapes being what they are, they haven't held up well over the years ( Read more... )

An actual recent patch submitted for the Linux kernel:
--- a/include/linux/freezer.h 2009-09-21 20:34:17.579233461 -0700 ( Read more... )

In my last post, I said:
My experiments within the spreadsheet suggest cumulative error from computing p(t) incrementally gets significant fairly quickly. I can compute p(t) directly, rather than incrementally computing a(t) to use to incrementally calculate v(t) to use to incrementally compute p(t). I just have to be careful to optimize that ( Read more... )

I kept thinking about the camera problem, and I think I've come up with a clever and rather simple solution that does pretty much exactly what I want. ( And I hid all the math in here. )

The term "endian" comes to us from Jonathan Swift by way of Gulliver's Travels. It seems that the Lilliputians were a divisive sort, having (rather brutally) divided themselves into two groups: Those who ate their boiled eggs starting at the small, pointy end (the "little end"), and those who started at the much more round end (the "big end"). ( Read more... )

I've thought about the camera panning problem some more.

( Click here for more math-i-ness )

I'm trying to work out a reasonable set of formulas to describe "camera panning" for a video game. ( Click here unless you were told there would be no math. )

On our DSP, we have a number of memory mapped registers for our various peripherals, device configuration, and so on. I came up with a nifty (or maybe not) way of using C++ templates and preprocessor defines to make them look like C++ variables in a program ( Read more... )

Awhile back, I wrote a program that was trying to solve a design verification problem. It was trying to find a compact set of tests that moved the design through as much coverage space as possible. It used a searching algorithm to try to find low-cost ways to reach each state. Most importantly, it built tests incrementally, taking existing " ( Read more... )