Amit’s A* Pages served as my primary reference for how the algorithm works. That’s definitely the place to go if you want to learn about it.

For my first implementation of the algorithm, I did a very straightforward implementation: I had a 2D grid of locations with movements costs, a list of closed off locations, and a list of open locations being considered. The data structures looked like this (with some unimportant details elided):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// This class is just an NSArray of waypoints
@class Path;

@interface PathNode : NSObject
{
    float fValue, gValue, hValue;
    MapCoordinate coordinate;
    PathNode *parent;
}
@end

@interface Pathfinder : NSObject
{
    NSMutableArray *_openList;
    NSMutableArray *_closedList;

    // CollisionMap is just a 2D grid of movement costs with some
    // nice accessor functions
    CollisionMap *_collisionMap;
}

...
- (Path*)pathFromStart:(CGPoint)startPosition toEnd:(CGPoint)endPosition;
@end

There are three important details about this first implementation:

• The open and closed lists are kept in NSMutableArrays. The open list is kept sorted at insertion time. Checking for membership in one of the lists means scanning through the list.
• PathNodes are dynamically allocated.
• This implementation was dog slow.

On an iPad 2 with a moderately sized map, finding a decent length path took 200ms. Totally not acceptable. I expected the first pass to be bad; in particular I expected maintaining the sorted open list to perform terribly. So I fired up Instruments, captured a trace, and the results looked like this:

By far the thing taking the most time was looking through the open and closed lists for a previously allocated PathNode (indexOfCoordinate:inList:). Maintaining the open list took almost no time next to that.

I was breaking other rules too: in particular, allocating and deallocating those PathNodes at runtime was a bad idea. So, armed with the profiler results, I took a second shot at the implementation.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

struct PathfindingCell
{
    MapCoordinate coordinate;
    float f, g, h;
    struct PathfindingCell *parent;
    struct PathfindingCell *openPrevious, *openNext;
    struct PathfindingCell *closedPrevious, *closedNext;
};

typedef struct PathfindingCell PathfindingCell;

@interface Pathfinder : NSObject
{
    CollisionMap *_collisionMap;

    int _cellsWide;
    int _cellsHigh;
    PathfindingCell *_cells;

    PathfindingCell *_openListHead;
    PathfindingCell *_closedListHead;
}
- (id)initWithCollisionMap:(CollisionMap *)collisionMap;
- (Path*)pathFromStart:(CGPoint)startPosition toEnd:(CGPoint)endPosition;

This time:

• I keep a 2D array of PathfindingCells with the same dimensions as the input CollisionMap. This is allocated once when the Pathfinder object is created, and never again.
• Instead of using NSMutableArrays, I now keep list links directly in the PathfindingCell structs.
• As a result of those two properties, I can now:
  • Directly look up any cell given an x,y location.
  • Determine whether a cell is in the open or closed list without traversing the list.
• Only one allocation is made for each run, and that’s for the Path object that gets returned from the pathFromStart:toEnd: method.

Importantly, the algorithm didn’t change, but the data layout did. With these changes, a profiler run for the same map and path now looks like this:

That’s better. I could probably make it faster; maybe a priority queue would work better than the insertion-sorted list I’m using now, and I could pre-allocate a fixed length Path object or something else, but it’s fast enough for me now, so I stopped at this point.

I posted the source code for the implementation as a Github Gist. It’s just the A* implementation without any drawing code or anything, but hopefully it’ll still be useful to learn from.

Here’s the idea: I want to be able to tap on a map view and drop a pin. I don’t want to try and subclass the map view, and the MKMapViewDelegate protocol doesn’t give you access to taps.

However, it is still a normal view, and that means I can attach UIGestureRecognizers to it.

For a first, straightforward attempt, let’s just create a basic Window based iOS application. (I hear this is gone in iOS 5.0; you can get one back from Big Nerd Ranch here: Window-Based Application.) Drop an MKMapView on your window and hook it up to your App Delegate. If you want, tell it to show the user location and zoom in on whatever region.

If you have Big Nerd Ranch’s iOS Programming, the Whereami application in Chapter 5 is pretty much the starting point I’m using. There’s a link at the bottom of the post for a demo project as well.

Now, let’s add a UITapGestureRecognizer to catch taps on the map:

1
2
3
4
5
6
7
8

- (BOOL)application:(UIApplication *)app didFinishLaunchingWithOptions:(NSDictionary *)options
{
    ...
    UITapGestureRecognizer *tapGesture = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleTap:)];
    [mapView addGestureRecognizer:tapGesture];
    [tapGesture release];
    ...
}

And the method that’ll be called when the taps are caught. We only want single taps, so let’s try and filter that out:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

- (void)handleTap:(id)sender
{
    UITapGestureRecognizer *tapGesture = (UITapGestureRecognizer*)sender;

    CGPoint tapPoint = [tapGesture locationInView:mapView];
    CLLocationCoordinate2D coord = [mapView convertPoint:tapPoint toCoordinateFromView:mapView];

    NSUInteger numberOfTouches = [tapGesture numberOfTouches];

    if (numberOfTouches == 1) {
        NSLog(@"Tap location was %.0f, %.0f", tapPoint.x, tapPoint.y);
        NSLog(@"World coordinate was longitude %f, latitude %f", coord.longitude, coord.latitude);
    } else {
        NSLog(@"Number of touches was %d, ignoring", numberOfTouches);
    }
}

Build and run, and at first glance, this works just fine. Tap and watch the logs and it’ll tell you both the window location and world location that your finger dropped. You can still tap and drag to move the view around and pinch to zoom, so we haven’t broken anything.

However, try double tapping. The map will still zoom properly, but it’s still going to call handleTap:, even with the check for number of touches. Bummer.

UIGestureRecognizers can be set up to require one or more other recognizers to fail, so let’s give that a try. We’ll add another UITapGestureRecognizer and set its minimum number of taps to 2, and then require that it fail before the original recognizer will work.

1
2
3
4
5
6
7
8
9
10
11
12

...
UITapGestureRecognizer *doubleTap = [[UITapGestureRecognizer alloc] init];
[doubleTap setNumberOfTapsRequired:2];
[doubleTap setCancelsTouchesInView:NO];
[mapView addGestureRecognizer:doubleTap];

UITapGestureRecognizer *tapGesture = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleTap:)];
[tapGesture requireGestureRecognizerToFail:doubleTap];
[mapView addGestureRecognizer:tapGesture];
[tapGesture release];
[doubleTap release];
...

Build and run, and sweet! Now we’re only catching single taps in handleMap:!

However, now double tapping to zoom is broken. It looks like we’re interfering with MKMapView’s internal gesture recognizers now. Let’s take a look at those.

1
2
3
4
5
6

...
NSArray *gestureRecognizers = [mapView gestureRecognizers];
for (UIGestureRecognizer *recognizer in gestureRecognizers) {
    NSLog(@"%@", recognizer);
}
...

Running that will show us something like this:

1
2
3
4
5
6
7
8

2011-12-15 21:20:51.844 TouchTheMap[1207:207] <UILongPressGestureRecognizer: 0x5a199c0; state = Possible; cancelsTouchesInView = NO; view = <MKMapView 0x5847a40>; target= <(action=handleLongPress:, target=<MKMapView 0x5847a40>)>>
2011-12-15 21:20:51.846 TouchTheMap[1207:207] <UITapGestureRecognizer: 0x5a19200; state = Possible; view = <MKMapView 0x5847a40>; target= <(action=handleTap:, target=<MKMapView 0x5847a40>)>; must-fail = {
        <UITapGestureRecognizer: 0x5a19b90; state = Possible; view = <MKMapView 0x5847a40>; target= <(action=handleDoubleTap:, target=<MKMapView 0x5847a40>)>; numberOfTapsRequired = 2>
    }>
2011-12-15 21:20:51.846 TouchTheMap[1207:207] <UITapGestureRecognizer: 0x5a19b90; state = Possible; view = <MKMapView 0x5847a40>; target= <(action=handleDoubleTap:, target=<MKMapView 0x5847a40>)>; numberOfTapsRequired = 2; must-fail-for = {
        <UITapGestureRecognizer: 0x5a19200; state = Possible; view = <MKMapView 0x5847a40>; target= <(action=handleTap:, target=<MKMapView 0x5847a40>)>>
    }>
2011-12-15 21:20:51.846 TouchTheMap[1207:207] <UITapGestureRecognizer: 0x5a19db0; state = Possible; view = <MKMapView 0x5847a40>; target= <(action=handleTwoFingerTap:, target=<MKMapView 0x5847a40>)>; numberOfTouchesRequired = 2>

So there are already UITapGestureRecognizers in there for both single and double taps. I have no idea what the single tap one does, but the double tap one probably handles zooming. Maybe we can just hijack that one.

So rip out the double tap recognizer we added, and dig through the built-in recognizers to find the double tap one and rely on that one instead.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

...
UIGestureRecognizer *builtInDoubleTap = nil;
NSArray *gestureRecognizers = [mapView gestureRecognizers];
for (UIGestureRecognizer *recognizer in gestureRecognizers) {
    if ([recognizer class] == [UITapGestureRecognizer class]) {
        if ([(UITapGestureRecognizer *)recognizer numberOfTapsRequired] == 2) {
            NSLog(@"Found double tap recognizer: %@", recognizer);
            builtInDoubleTap = recognizer;
            break;
        }
    }
}

UITapGestureRecognizer *tapGesture = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleTap:)];
[tapGesture requireGestureRecognizerToFail:builtInDoubleTap];
[mapView addGestureRecognizer:tapGesture];
[tapGesture release];
...

Build and run, and bingo. A single tap on the map will report the tap location in the Debug console, and a double tap will still zoom properly.

I have only tested this in the simulator so far, as I’m cheap and haven’t ponied up the cash for a developer license yet. So this might not work in the wild.

A sample project is up on GitHub named TouchTheMap. I’ll be adding to that project in later posts, so if you want the version of the code as of this posting, grab the 2011-12-15_touch_tracking tag.

Update

I figured out what that single tap gesture recognizer is in there for. MKMapView uses it to catch when you tap on annotations. Unfortunately, adding your own single tap recognizer causes the built in one to no longer get called, breaking that functionality. So if you need annotations, this is probably not a good idea.

I managed to scratch the camera lens on my phone, so there’s a blurry corner in these pictures. Need to replace that.

I’m going to preface this with two caveats: I am a college dropout, and I have no certifications whatsoever. I attended a University for 5 years before deciding to drop out; it got to the point where I’d taken all of the Computer Science classes I cared to and all that was left was a bunch of general education stuff that I didn’t want to spend any more time and money on. I’m not really sure whether the lack of that degree has hurt me. I still manage to get in to job interviews, and of the 6 or 7 positions I’ve interviewed for in the last 5 years, I’ve gotten offers at all but 2 of them.

If you don’t have any experience at all in IT, the most important thing I can suggest is getting that experience. Ever set up a website before? That’s a good place to start:

• Register a domain name (e.g. yourname.com or something)
• Find hosting
• Make a basic, static website. (HTML + images only)
• Got the hang of that? Now go further: set up a dynamic website; Wordpress is an excellent starting point
• Find out what a database is, what PHP is, what Javascript is, etc.

That all sounds more like web developer stuff than straight IT, but a good IT person ends up needing to be able to handle a little bit of everything, and you need to know if you enjoy this stuff at all. If you hate it, you want a different career.

Learn Unix. Windows is ubiquitous on desktop computers, but Unix provides the backbone of the Internet. Not knowing it will hurt an IT person. It’s easy to get started in: download Ubuntu, install it alongside Windows (assuming you have a Windows computer), and start playing.

Before you do that, back up everything. Backups are not something you want to learn about the hard way.

Have a Mac? Congrats, you’re already using a Unix machine. Launch Terminal and start playing.

Really, the single most important skill you can have going into the IT field is the ability to learn. Constantly. Things never stop changing, new things pop up every day, and you’ll never get to the point where you can stop learning new things. You have to be ok with that, and even enjoy it if you’re going to make it in IT.

Ingredients

• 1 pound smoked sausage (I use beef, but pork is good too)
• 1 green bell pepper
• 1 white onion
• (optional) a few stalks of celery
• 2 cloves of garlic, minced (I use the pre-minced stuff in a jar, because I am lazy)
• 3/4 cup white rice
• 14 oz. tomato sauce
• 11 oz. chicken broth
• 1/2 tsp. ground thyme
• 1/4 tsp. cayenne pepper
• 1/4 tsp. white pepper
• 1 bay leaf
• Dash of Worcestershire sauce

Instructions

1. Dice the bell pepper, chop up the onion and celery, slice up the sausage. Start cooking the sausage over medium-high heat in a largish skillet until it begins to render its fat, then add the bell pepper, onion and celery.

2. Cook the above until the onion turns clear, stirring occasionally.

3. Add the garlic, cook for another minute.

4. Turn the heat down to medium low and drain the fat, if you wish. (I usually don’t bother when cooking with beef sausage.) Stir in the rice, coating the sausage and veggies with it.

5. Add the rest of the ingredients, stir well, and simmer covered for 20 or sominutes, or until the rice has cooked fully. Stir it every few minutes; the bottom layer likes to stick to the pan.

6. Fish out the bay leaf (you don’t want to bite into it by mistake), and serve!

When I make this for myself, I usually pig out on it for dinner and have enough left over for two lunches afterward. It still tastes great after reheating in a microwave.

This isn’t as good as the real stuff at fairs, but it’ll do in a pinch. It also costs maybe 20 - 30 cents per batch, rather than a buck or more for prepackaged microwave kettle corn.

• 1/4 cup of popping kernels
• 1/8 cup sugar
• 1/8 cup vegetable or canola oil

Toss all of that in a medium-large sauce pan WITH A LID (very important). Heat it on medium high, and once it starts popping shake it like you would Jiffy Pop. The sugar will melt while you’re cooking and should coat everything evenly.

If you try this without a lid, you will pay the ultimate price. Seriously, like hot cooking oil all over you. Bad times.

Toss it in a bowl and salt to taste when the kernels stop popping.

I really dig that Octopress lets me keep all of my entries in simple Markdown formatted text files. I can stick them in a VCS repository and always have easily backed up and readable versions of the articles; no mucking around with a database, and they don’t need to be HTML formatted.

There was a 4 year gap in my blogging from 2007-2011; most of that content was pretty ancient and I doubt it’s of much use to anyone, so I haven’t gotten around to importing the old stuff into the new software yet. I’ll probably bring stuff in slowly over time.

• Download and install SBCL (http://www.sbcl.org/)

• Download and install Emacs (http://www.gnu.org/software/emacs/)

• Download and install Quicklisp (http://www.quicklisp.org/)

• Configure everything so that it plays nice together.

I’m doing this under Ubuntu 10.04, but I’m only using the package manager for Emacs so this should translate well across multiple distributions.

Download and install SBCL

SBCL is probably the most popular Common Lisp implementation available for Linux. There are other great ones out there (Clozure CL and CLISP come to mind), but SBCL’s the one I usually use.

Go to SBCL’s download page and download the latest release for Linux. (Both 32-bit and 64-bit work great).

Now fire up a terminal, switch to where you downloaded SBCL, unpack and install it:

1
2
3
4

user@localhost:~$ cd Downloads/
user@localhost:~/Downloads$ tar xjf sbcl-1.0.45-x86-linux-binary.tar.bz2
user@localhost:~/Downloads$ cd sbcl-1.0.45-x86-linux
user@localhost:~/sbcl-1.0.45-x86-linux$ sudo sh install.sh

That’ll install SBCL into /usr/local/bin. At this point you should be able to run ‘sbcl’ and get a Lisp prompt:

1
2
3
4
5
6
7
8

user@localhost:~/sbcl-1.0.45-x86-linux$ sbcl
This is SBCL 1.0.45, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.
SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.
*

Hit Control-D or type (quit) to exit.

Install Emacs

Use your package manager for this. On Ubuntu:

1
2

user@localhost:$ apt-get update
user@localhost:$ apt-get install emacs

Download and install Quicklisp

Download Quicklisp from http://www.quicklisp.org/. (It’s in beta at the time this was written, but it’s fully functional and awesome). Download the install file (http://beta.quicklisp.org/quicklisp.lisp at the time of writing) and save it to disk somewhere easy to find.

Next, run sbcl and type in the following:

1

(load "/path/to/quicklisp.lisp")

After it loads, run:

1

(quicklisp-quickstart:install)

That’ll download the rest of the system and get it set up for you. Quicklisp will install by default in ~/quicklisp; you can change that by passing :path "/target/path/" to the install function.

Finally, run:

1

(ql:add-to-init-file)

That’ll add Quicklisp to your init file so that anytime you run SBCL Quicklisp will be loaded and ready to go.

Now go ahead and read on http://www.quicklisp.org/ about how to use it. It’s very easy to search for and install Common Lisp libraries. For example, to get ahold of “ieee-floats” for the previous entry, just run:

1

(ql:quickload "ieee-floats")

That will download the library if it hasn’t already and load it into your CL environment for you.

Configure everything so that it plays nice together

SBCL and Quicklisp are already playing nicely together at this point; you just need to let Emacs know about them.

First in SBCL run:

1

(ql:quickload "quicklisp-slime-helper")

This’ll install SLIME (http://common-lisp.net/project/slime/) for you, an awesome Common Lisp development environment. It should give you a line to add to your .emacs configuration file:

1
2
3
4
5

slime-helper.el installed in "/Users/jfischer/quicklisp/slime-helper.el"

To use, add this to your ~/.emacs:

    (load (expand-file-name "~/quicklisp/slime-helper.el"))

You’ll need to both add that line and tell Emacs how to launch your Lisp environment. To do that, add the following to ~/.emacs:

1
2

(setq inferior-lisp-program "sbcl")
(load (expand-file-name "~/quicklisp/slime-helper.el"))

At this point, you should be ready to go. To try it all out, launch Emacs, type Alt-x (Meta-x, technically), and type in “slime”. Hit enter and you should find yourself at a CL-USER prompt within Emacs.

Now, actually learning to use SLIME is well beyond the scope of this entry. For that, I recommend Peter Seibel’s Practical Common Lisp. Chapter 2 covers getting around both in Emacs and SLIME.

High-level overview:

• Download and install SBCL (http://www.sbcl.org/)

• Download and install Aquamacs (http://aquamacs.org/)

• Download and install Quicklisp (http://www.quicklisp.org/)i>

• Configure everything so that it plays nice together.

Download and install SBCL

There are several good Common Lisp implementations on Mac OS X. I happen to use SBCL because it worked better with lispbuilder-sdl last time I tried it, so that’s the one I cover here. Clozure CL (http://ccl.clozure.com/) is also very good.

Unfortunately, the SBCL maintainers don’t keep the pre-built Mac version up to date, so getting the latest SBCL is a two-step process on Mac OS X. First, hit SBCL’s download page and download both the latest source (1.0.45 at the time of writing) and the latest Mac binary (1.0.29). I’m using a 64-bit SBCL, but 32-bit should work fine as well.

Update: This has changed recently; the last several releases of SBCL have been pre-built for Mac OS X, so you can just grab one of those.

Now fire up Terminal, switch to where you downloaded SBCL, unpack and install it:

1
2
3
4

Solace:~ jfischer$ cd Downloads/
Solace:Downloads jfischer$ tar xjf sbcl-1.0.29-x86-darwin-binary-r2.tar.bz2
Solace:Downloads jfischer$ cd sbcl-1.0.29-x86-darwin
Solace:sbcl-1.0.29-x86-darwin jfischer$ sudo sh install.sh

That’ll install SBCL into /usr/local/bin. At this point you should be able to run sbcl and get a Lisp prompt:

1
2
3
4
5
6
7
8

Solace:sbcl-1.0.29-x86-darwin jfischer$ sbcl
This is SBCL 1.0.29, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.
SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.
*

Hit Control-D or type (quit) to exit.

Now you can run w/ that version, or if you want the latest/greatest you may need to build it. (Note: you may need Apple’s developer tools installed for this; I can’t remember.) Go back to your downloads directory and unpack the source distribution:

1
2
3
4

Solace:Downloads jfischer$ tar xjf sbcl-1.0.45-source.tar.bz2
Solace:Downloads jfischer$ cd sbcl-1.0.45
Solace:Downloads jfischer$ sh make.sh
Solace:Downloads jfischer$ sudo sh install.sh

Now you’ll have the latest and greatest SBCL installed.

Download and install Aquamacs

Aquamacs (http://aquamacs.org/) is an Emacs distribution customized to run nicely on Mac OS X. It obeys all the normal Mac shortcut keys, prints well, that sort of thing. Download it, open it up and drag the application to your Application directory as you would any other Mac app.

Download and install Quicklisp

Download Quicklisp from http://www.quicklisp.org/. (It’s in beta at the time this was written, but it’s fully functional and awesome). Download the install file (http://beta.quicklisp.org/quicklisp.lisp at the time of writing) and save it to disk somewhere easy to find.

Next, run sbcl and type in the following:

1

(load "/path/to/quicklisp.lisp")

After it loads, run:

1

(quicklisp-quickstart:install)

That’ll download the rest of the system and get it set up for you. Quicklisp will install by default in ~/quicklisp; you can change that by passing :path "/target/path/" to the install function.

Finally, run:

1

(ql:add-to-init-file)

That’ll add Quicklisp to your init file so that anytime you run SBCL Quicklisp will be loaded and ready to go.

Now go ahead and read on http://www.quicklisp.org/ about how to use it. It’s very easy to search for and install Common Lisp libraries. For example, to get ahold of “ieee-floats” for the previous entry, just run:

1

(ql:quickload "ieee-floats")

That will download the library if it hasn’t already and load it into your CL environment for you.

Configure everything so that it plays nice together

SBCL and Quicklisp are already playing nicely together at this point; you just need to let Aquamacs know about them.

First in SBCL run:

1

(ql:quickload "quicklisp-slime-helper")

This’ll install SLIME (http://common-lisp.net/project/slime/) for you, an awesome Common Lisp development environment. It should give you a line to add to your .emacs configuration file:

1
2
3
4
5

slime-helper.el installed in "/Users/jfischer/quicklisp/slime-helper.el"

To use, add this to your ~/.emacs:

    (load (expand-file-name "~/quicklisp/slime-helper.el"))

Aquamacs will use .emacs, but they recommend keeping your configuration in ~/Library/Preferences/Aquamacs Emacs/Preferences.el. Either will work. You’ll need to both tell Aquamacs how to start your Lisp environment and add the above line to tell it how to find SLIME. To do that, add the following to your Preferences.el:

1
2

(setq inferior-lisp-program "sbcl")
(load (expand-file-name "~/quicklisp/slime-helper.el"))

At this point, you should be ready to go. To try it all out, launch Emacs, type Alt-x (Meta-x, technically), and type in “slime”. Hit enter and you should find yourself at a CL-USER prompt within Emacs.

Now, actually learning to use SLIME is well beyond the scope of this entry. For that, I recommend Peter Seibel’s Practical Common Lisp. Chapter 2 covers getting around both in Emacs and SLIME.

• Download and install CLISP (http://clisp.cons.org/)

• Download and install Emacs (http://www.gnu.org/software/emacs/)

• Download and install Quicklisp (http://www.quicklisp.org/)

• Configure everything so that it plays nice together.

Download and install CLISP

Download CLISP from Sourceforge here: http://sourceforge.net/projects/clisp/files/clisp/2.48/.

Note: the latest version (at the time of writing) is 2.49, but it reportedly has problems with Windows paths and I’m having trouble getting it to load SLIME properly, so for now I’m recommending 2.48.

You want clisp-2.48-win32-mingw-big.exe. (The “big” download is only 1.1 MiB larger and includes a larger pre-built library). Run the installer, and feel free to choose the defaults. CLISP will end up being installed at C:\Program Files\clisp-2.48, and it will add that directory to your PATH (which is important later).

Unfortunately, there’s a bug in the 2.48 installer. You’ll need to copy a file into the right place to launch 2.48 successfully. Open up Explorer and browse to C:\Program Files\clisp-2.48 (or wherever you installed it.)

In the clisp-2.48 directory there’ll be another directory named libsvm; copy svm.dll out of that directory and place it in clisp-2.48\full.

Once that’s done there’s a CLISP link in your Start Menu; you should be able to run it and see the following:

To quit just hit Control-D or type in (quit) and hit enter.

Download and install Emacs

Pre-built binaries for the latest Emacs are available at http://ntemacs.sourceforge.net/. You can download the latest CVS binary, or you can go back to the last stable release. The latest CVS is probably fine though.

Unforunately they’re only offering .7z files at the moment, so you’ll probably need to grab 7zip (http://www.7zip.org/) as well if you don’t have it already.

Extract the ntemacs file wherever you’d like it installed (C:\Program Files works fine). In ntemacs24/bin you’ll see a file named runemacs.exe; make a shortcut to that someplace handy (Desktop, Start Menu, etc.). Go ahead and run it to make sure it loads; you’ll need it in a moment.

Download and install Quicklisp

Download Quicklisp from http://www.quicklisp.org/. (It’s in beta at the time this was written, but it’s fully functional and awesome). Download the install file (http://beta.quicklisp.org/quicklisp.lisp at the time of writing) and save it to disk somewhere easy to find.

Next, run CLISP and type in the following:

1

(load "C:/path/to/quicklisp.lisp")

Notice that you’ll need to use forward slashes instead of Windows normal backslashes. (Or if you want you can use \\).

After it loads, run:

1

(quicklisp-quickstart:install :path "C:\\quicklisp\\")

Note: By default Quicklisp tries to install in $HOME/quicklisp. It tries to figure out where that is by running (user-homedir-pathname), which as far as I can tell relies on $HOME being set properly. Unfortunately, Windows (version 7 at least) sets up $HOME differently depending on how you ran the program. If you run CLISP on the command line, $HOME won’t be set at all so it’ll use $USERPROFILE instead. If you run it from Emacs (as we will be later), $HOME will be set and you’ll get a different directory ($APPDATA). All in all, it’s arg-inspiring.

Long story short, we’re installing it in a known location. (C:\quicklisp). That’s why we’re passing a path above. The trailing \ is important; don’t leave that off.

That’ll download the rest of the system and get it set up for you.

Now go ahead and read on http://www.quicklisp.org/ about how to use it. It’s very easy to search for and install Common Lisp libraries. For example, to get ahold of “ieee-floats” for the previous entry, just run:

1

(ql:quickload "ieee-floats")

That will download the library if it hasn’t already and load it into your CL environment for you.

Configure everything so that it plays nice together

First, CLISP is going to need some configuration to find temporary directories properly. Not sure why, but SLIME (the IDE we’ll be setting up in Emacs) will barf complainining about the temporary directory if we don’t do this.

Open up $HOME\.clisprc.lisp (e.g. C:\Users\username\AppData\Roaming\.clisprc.lisp. Ain’t Windows grand?) in a text editor. (Emacs, for example:)). Add the following:

1
2
3
4
5
6
7
8
9
10

;;; Load Quicklisp when CLISP launches
#-quicklisp
(let ((quicklisp-init "C:\\quicklisp\\setup.lisp"))
  (when (probe-file quicklisp-init)
    (load quicklisp-init)))

;;; Fix for CLISP on Windows.
(setf temporary-file-directory "C:\\<home-directory>\\AppData\\Local\\Temp")
(setf (ext:getenv "temp") temporary-file-directory)
(setf (ext:getenv "tmp") temporary-file-directory)

Replacing <home-directory> with your home directory. (e.g. C:/Users/whomever). This should work for Windows Vista and 7, on Windows XP use C:\<home-directory>\AppData\Temp. Go ahead and save that file; you should be done with it now.

Next, run CLISP again and enter the following:

1

(ql:quickload "quicklisp-slime-helper")

This’ll install SLIME (http://common-lisp.net/project/slime/) for you, an awesome Common Lisp development environment.

Last, open up your Emacs configuration file. The easiest way to find this is to just launch Emacs and type in Ctrl-x, Ctrl-f and enter ~/.emacs in the prompt at the bottom of the window.

In that file, add the following lines:

1
2

(setq inferior-lisp-program "clisp.exe")
(load "C:\\quicklisp\\slime-helper.el")

At this point, you should be ready to go. To try it all out, launch Emacs, type Alt-x (Meta-x, technically), and type in “slime”. Hit enter and you should find yourself at a CL-USER prompt within Emacs.

Now, actually learning to use SLIME is well beyond the scope of this entry. For that, I recommend Peter Seibel’s Practical Common Lisp (http://www.gigamonkeys.com/book). Chapter 2 covers getting around both in Emacs and SLIME. (It talks about Lisp in a Box, which is sadly unmaintained at this point, hence this blog post).

Really, if you’re at all interested in learning Common Lisp then PCL is an excellent resource, and I suggest you buy a copy. I’ve just about worn mine out. :)

Since I’m still in the prototyping/flesh out stage, my level needs are pretty simple. The goal I’m shooting for is easier to show than to tell, so take a look:

That’s the basic level I’m shooting for at this point. Basically a chessboard with differing heights. It’s inspired by Danc’s Miraculously Flexible Prototyping Tiles. So think Legos, or Minecraft.

I want an easy way to specify this, in just a text file. So what pieces of information do I need at this point?

• Dimensions of the board (width/height in squares)

• Heights at any given place

• And because I’m incapable of running with just blank squares, what sort of texture to use on each block

And because I want to make things pretty:

• Background texture

• Light color/direction

I’ll need to add more in the future (object placement, unit starting locations, etc), but that’s enough to get going. Let’s take a first pass at a text format for this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

dimensions 12 12
num-layers 2
background "cloudy-sky.png"
light-color #D1AE4D
light-direction -0.1212 -0.4848 0.4848

layer 2 2 2 2 2 2 2 2 2 2
      2 2 2 2 2 2 2 2 2 2
      2 2 2 6 6 2 2 2 2 2
      2 2 2 6 6 2 2 2 2 2
      2 2 2 6 6 6 2 2 2 2
      2 2 2 2 6 6 2 2 2 2
      2 2 2 2 2 2 2 2 2 2
      2 2 2 2 2 2 2 2 2 2
      2 2 2 2 2 2 2 2 2 2
      2 2 2 2 2 2 2 2 2 2

layer 3 5 5 3 3 3 3 3 3 3
      3 5 5 3 3 3 3 3 3 3
      3 5 5 0 0 3 3 3 3 3
      3 5 5 0 0 3 3 3 3 3 
      3 5 5 0 0 0 3 3 3 3
      3 5 5 3 0 0 3 3 3 3
      3 5 5 3 3 3 3 3 3 3
      3 5 5 3 3 3 3 3 3 3
      3 5 5 3 3 3 3 3 3 3
      3 5 5 3 3 3 3 3 3 3

Most of those fields are self explanatory. Dimensions are just width and height, light-color is a HTML/CSS style color specifier, the direction is a 3 component vector.

Remember, the level is structured like a collection of legos that all happen to be a uniform size, so we can consider it as a set of flat layers. There are 2 layers in this map, hence num-layers.

Finally, the layer fields give you the actual block layouts. Each number corresponds to a block type in the game code, with 0 representing an empty space. (If you’re curious, 2 is dirt, 3 is grass, 5 is stone and 6 is water). There will be (width * height) numbers following each layer command.

It’s simple and relatively easy to type in by hand. But damn, that means I have to write a parser. I hate writing text parsers. But I have an idea! Let’s try massaging that text format into something a little more structured:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

(define-map
 (name "The Blocky River")
 (background "cloudy-sky.png")
 (light-color 209 174 77)
 (light-direction -0.1212 -0.4848 0.4848)

 (dimensions 10 10)
 (layer 2 2 2 2 2 2 2 2 2 2
        2 2 2 2 2 2 2 2 2 2
        2 2 2 6 6 2 2 2 2 2
        2 2 2 6 6 2 2 2 2 2
        2 2 2 6 6 6 2 2 2 2
        2 2 2 2 6 6 2 2 2 2
        2 2 2 2 2 2 2 2 2 2
        2 2 2 2 2 2 2 2 2 2
        2 2 2 2 2 2 2 2 2 2
        2 2 2 2 2 2 2 2 2 2)

 (layer 3 5 5 3 3 3 3 3 3 3
        3 5 5 3 3 3 3 3 3 3
        3 5 5 0 0 3 3 3 3 3
        3 5 5 0 0 3 3 3 3 3
        3 5 5 0 0 0 3 3 3 3
        3 5 5 3 0 0 3 3 3 3
        3 5 5 3 3 3 3 3 3 3
        3 5 5 3 3 3 3 3 3 3
        3 5 5 3 3 3 3 3 3 3
        3 5 5 3 3 3 3 3 3 3))

That is an s-expression (http://en.wikipedia.org/wiki/S-expression). They happen to be super easy to parse and are probably best known as the syntax of the Lisp family of languages. But I still don’t want to write a parser.

Instead, I’m going to fire up a Common Lisp environment and let that handle parsing it:

1
2
3
4
5
6
7
8
9
10

CL-USER> (with-open-file (f "/Users/jfischer/Desktop/map-sexp.txt")
           (read f))
(MAP (NAME "The Blocky River") (BACKGROUND "cloudy-sky.png")
     (LIGHT-COLOR "#d1ae4d") (LIGHT-DIRECTION -0.1212 -0.4848 0.4848)
     (LAYER 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 6 6 2 2 2 2 2 2 2 2 6
      6 2 2 2 2 2 2 2 2 6 6 6 2 2 2 2 2 2 2 2 6 6 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
      2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)
     (LAYER 3 5 5 3 3 3 3 3 3 3 3 5 5 3 3 3 3 3 3 3 3 5 5 0 0 3 3 3 3 3 3 5 5 0
      0 3 3 3 3 3 3 5 5 0 0 0 3 3 3 3 3 5 5 3 0 0 3 3 3 3 3 5 5 3 3 3 3 3 3 3 3
      5 5 3 3 3 3 3 3 3 3 5 5 3 3 3 3 3 3 3 3 5 5 3 3 3 3 3 3 3))

Now easy as that, instead of a text file I have a data structure that I can pull apart and use to define the level.

First, let’s make a basic container class to hold the information, and a quick function to take the list (s-expression) above and turn it into an instance of that container class.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

;; Helper structure to hold the data.  Not really necessary, but it makes
;; the rest of the code cleaner
(defclass blockmap ()
  ((name        :accessor map-name)
   (background  :accessor map-background)
   (light-color :accessor map-light-color)
   (light-dir   :accessor map-light-dir)
   (width       :accessor map-width)
   (height      :accessor map-height)
   (layers      :accessor map-layers :initform (list))))

;; Parse a list of the above form out into a blockmap class
(defun parse-blockmap-list (l)
  (let ((map    (make-instance 'blockmap))
        (fields (cdr l)))
    (loop for item in fields do
         (let ((key (first item))
               (value (second item)))
           ;; This is pretty much just a switch statement.  The format
           ;; has each field as a list with the first value being the
           ;; field name/type.
           (cond ((eq key 'name)
                  (setf (map-name map) value))
                 ((eq key 'background)
                  (setf (map-background map) value))
                 ((eq key 'light-color)
                  (setf (map-light-color map) (cdr item)))
                 ((eq key 'light-direction)
                  (setf (map-light-dir map) (cdr item)))
                 ((eq key 'dimensions)
                  (setf (map-width map) (first (cdr item)))
                  (setf (map-height map) (second (cdr item))))
                 ((eq key 'layer)
                  (push (cdr item) (map-layers map)))
                 (t
                  (format t "Unknown key ~a~%" key)))))
    map))

Now to load a file and turn it into a blockmap object we do:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

CL-USER> (defvar my-blockmap (with-open-file (f "/Users/jfischer/Desktop/map-sexp.txt")
                             (parse-blockmap-list (read f))))
#<BLOCKMAP {1003290E21}>
CL-USER> (map-name my-blockmap)
"The Blocky River"
CL-USER> (length (map-layers my-blockmap))
2
CL-USER> (map-layers my-blockmap)
((3 5 5 3 3 3 3 3 3 3 3 5 5 3 3 3 3 3 3 3 3 5 5 0 0 3 3 3 3 3 3 5 5 0 0 3 3 3 3
  3 3 5 5 0 0 0 3 3 3 3 3 5 5 3 0 0 3 3 3 3 3 5 5 3 3 3 3 3 3 3 3 5 5 3 3 3 3 3
  3 3 3 5 5 3 3 3 3 3 3 3 3 5 5 3 3 3 3 3 3 3)
 (2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 6 6 2 2 2 2 2 2 2 2 6 6 2 2 2 2
  2 2 2 2 6 6 6 2 2 2 2 2 2 2 2 6 6 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
  2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))

Sweet, now all that’s left is to make it easily available to C. We could probably just write out .c files, but generating the proper syntax for that sounds tedious, so I’m just going to write out a binary format that we can load easily. Something like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

struct BlockMapFile
{
    uint8_t  magic;              // Identify the file type
    uint8_t  version;            // Cause you know you'll need it
    char     title[256];         // Fixed length strings make life happy
    char     background[256];
    uint32_t light_color;        // ARGB light color ready to drop into OpenGL
    float    light_direction[3]; // 32-bit floats written out as uint32s;
    uint8_t  num_layers;         // Dimensions of the layers
    uint8_t  width;
    uint8_t  height;
    uint8_t  layers[1];          // num_layers * width * height entries
};

// NOTE: Depending on the compiler you may need to worry about structure
// field alignment.  For GCC, add __attribute__((packed)) to the end
// of the above structure definition.

That can be loaded in one shot with a simple fread() or [NSData dataWithContentsOfFile:];. From there, just verify that the magic/version is good and you’re good to go.

To write that out from Common Lisp, we’ll need to pull in an extra library to deal with encoding floating point values. I use Marijn Haverbeke’s ieee- floats. With that, the code to write out a binary block map file looks like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

(defparameter *blockmap-magic* 123)
(defparameter *blockmap-version* 1)

;; Take a blockmap object and write it out to a file.
(defun write-blockmap (map filename)
  (with-open-file (f filename
                     :direction :output
                     :element-type '(unsigned-byte 8)
                     :if-exists :supersede)
    ;; Write out the header
    (write-byte *blockmap-magic* f)
    (write-byte *blockmap-version* f)

    ;; Then the title and background strings
    (write-sequence (make-c-string (map-name map)) f)
    (write-sequence (make-c-string (map-background map)) f)

    ;; Light color
    (write-int32 (make-argb (map-light-color map)) f)

    ;; Light direction
    (write-int32 (ieee-floats:encode-float32 (first (map-light-dir map))) f)
    (write-int32 (ieee-floats:encode-float32 (second (map-light-dir map))) f)
    (write-int32 (ieee-floats:encode-float32 (third (map-light-dir map))) f)

    ;; Layer information
    (write-byte (length (map-layers map)) f)
    (write-byte (map-width map) f)
    (write-byte (map-height map) f)

    ;; And the layers themselves
    (loop for layer in (map-layers map) do
         (let ((data (make-array (* (map-width map) (map-height map))
                                 :element-type '(unsigned-byte 8)
                                 :initial-contents

I’ve left out some helper functions (make-c-string, write-int32 and make-argb); they’re in the source package linked below. But really, that’s all there is to it.

So technically yes, I wrote a parser. But the language did all the hard work for me; I just took the data it provided and chucked it into a binary file. And importantly, it’s extremely easy to add/remove fields from this.

Source Code: s-expressions.zip

ModelViewer.zip

If you have an existing Egoboo installation, you’re going to want this file: egoboo-osx-r68.dmg. Just follow the directions in the included readme file.

If you want the new Egoboo 2.3.6 and you haven’t already downloaded it yet, grab the full thing here: egoboo-osx-2.3.6.dmg. Just open up that package, copy the folder inside it onto your hard drive somewhere (it can’t run within the package), and run Egoboo!

I’m also stoked as this release is using my Egoboo 2.x codebase. Brings a tear to my eye. :)

To get your copy, go here: http://home.no.net/egoboo

• Garbage Collection Good. It’s nice to not have to worry about things like ownership and null pointers. Combined with weak references, caching resources becomes clean and easy.

• LWJGL is pretty cool.

• From what I’ve been able to determine, performance is fine for a hobby game. It’s not like I’m going to try and keep up with mainstream graphics.

• Having things like java.util.Properties built-in is just a huge time- saver.

• If you’re interested in doing the Java game thing, cokeandcode.com is a great resource.

More later.

On a superficial and selfish level, it means an end to all the planning (which Jackie’s been doing most of), the errands, the worrying about budgets, all the build-up, all the questions, hopefully all of the useless and unfunny advice. It means a vacation, which I’m in sore need of. It means we can finally clear our apartment of all the decorations and pictures and floor mats and other things that we need for the day of the wedding. It means a night in an awesome hotel in Coronado, and 8 nights in awesome hotels in Hawaii. It means a day of ATV-ing on the big island, a luau, kayaking & snorkeling with the dolphins.

It means a release, and a hell of a lot of fun.

It means a lot more than that though. I first met Jackie at Danielle’s father’s funeral; just in passing, no real interaction. I remember her looking elegant in black, and having to trade off babysitting a puppy that’d been brought for some odd reason. After that, I full well forgot about her, and met her again six months later at my sister’s place. She’d moved in with Danielle, and Becky invited them and I to her place to hang out, have dinner, go swimming. I mostly remember being distracted by her posterior that evening; her shorts were just a smidge too short.

I saw Jackie a few times over the next several months, and on a whim one night Rob, Jocelyn and I decided to grab a bunch of people to go ice skating, and called Jackie and Danielle to join us. Ice skating became a regular thing, then hanging out at Rob’s place, having a few drinks, meeting up for dinner, the normal stuff friends do. We were always proper; Jackie and I never saw each other outside of that group of people, but I think everyone saw where it was heading.

Yes Karen, Jackie had a good bit to do with our breakup, but she wasn’t the only reason. A relationship over e-mail and IM wasn’t fair to either of us, and though I regret being such a coward about breaking it off with you, I’m completely convinced it was the right choice.

Jackie and I have been together since April 23rd, 2001. I can’t remember our first date, really, because by the time we were officially together we were completely comfortable with each other. I remember going to Ruth’s Chris steakhouse for my birthday, I remember Rob hitting a possum on the way home (the poor thing). I remember double dates with Rob and Jocelyn (Sammy’s!). I remember meeting her best friends for the first time in Mission Valley. (Was it at Chevy’s?)

I remember her sitting with me when dad passed away, holding me while I bawled like a baby. I don’t know how I would’ve made it through those months without her.

Jackie and I have been together for five and a half years now, and while I won’t presume to speak for her; I’ve never felt as.. complete, or content as I have in these years. I love her with all of my heart; with everything I have inside me. I will love her for as long as I live.

Not everything is all rosy and perfect, of course. We both have our bad days, and bad moods to go with. I’m given to laziness, so she has to nag me on occasion. We fight, but we’re so close in temperament that the fights have never been out of control. And for all that people tell us marriage is hard, that things change: so what? If it were easy, we wouldn’t cherish it, wouldn’t value it.

Really, the difficulties involved - the missteps we make along the way - are
what make it interesting.

I love her, and she loves me, and whatever else may come; whatever trials, setbacks, failures, successes, windfalls, jaguar attacks, earthquakes, apocalypses, floods, surprises, babies, kittens, etc., we’ll make it. We’ll be together for the rest of our lives.

And Saturday, we’ll pledge it formally in front of all the people we love.

I want to see books on Data Structures. I want discussions of the various algorithms for implementing a self-balancing binary tree. I know every modern language out there has a library that will do it for you, but that’s not what I want. I want to learn, to grow. When I’m writing an app for something sure, I’ll use the built-in, but when I’m programming for myself I want to try the complicated stuff. The Design Pattern books are part of the way there, but they don’t cover the meaty stuff.

Specifically, I’m currently looking for a good book on the design and implementation of compilers (e.g. the Dragon Book). I could just order one online, but I like being able to go flip through a book before I drop money on it. Call me old-fashioned.

Maybe I should just try a library. (The brick and mortar kind.)

Most of the books I’ve bought cover all kinds of info about how to write the various bits of a game engine, but they leave you with bits and not all that clear of an idea how they all get put together. Couple that with me being unable to ignore perfectionist tendencies and you’ll have a good idea of why I take awhile to get very far in my personal projects. :) This book is cool because it focuses on something so simple: your average MUD is text based; the most complicated part is handling the bits that go over the network. That leaves Mr. Penton plenty of time to discuss how it all works together.

He has enough room that he writes two full MUD engines; the first very simple and similiar to older-style game. It’s mostly hard-coded so any real changes require access to the codebase. His second engine is a great deal more flexible, and includes Python bindings and all that jazz.

So for $16.99, I’m stoked. It’s a good book. However, I would ask anyone who might be interested in reading it to have a firm grasp of how C++ works and what you can, can’t, should, or should not do in it, because Mr. Penton abuses the language in a number of ways.

First up, can anyone explain why you would do this:

1
2
3
4
5
6
7

class MyClass {
public:
    int& MyVariable() { return m_myVariable; }

private:
    int m_myVariable;
};

Rather than just:

1
2
3
4

class MyClass {
public:
  int m_myVariable; 
};

With the first variant, you have to call MyClass::MyVariable() to get access to the variable, but it returns a reference, so you can do things like:

1
2

MyClass m;
m.MyVariable() = 14;

What is the point in having the variable private in the first place? It is no longer protected from getting modified in bad ways, and you’re still exposing that implementation detail to the world. If you want a variable to be accessible to everyone, just make the darn thing public. If you don’t want it to be, use get/set functions. It’s much clearer what you’re trying to do, and you have more flexibility down the line to evolve the interface further.

Along the lines of accessor functions, Jonathan Blow makes some very good points in his “Implicit vs Explicit Software Engineering Costs” rant here: http://number-none.com/blow/rants.html. I personally tend to use accessor functions when I want to either 1) validate things before I set them, or 2) allow read-only access to variables. If it doesn’t fit in either category, it goes public.

Second nitpick on MUD Game Programming is C pre-processor abuse. Mr. Penton defines a couple macros that look like this:

1
2
3
4
5
6
7
8

#ifdef WIN32
WSADATA g_wsadata;
#define StartSocketLib WSAStartup( MAKEWORD(2, 2), &g_wsadata);
#define CloseSocketLib WSACleanup();
#else
#define StartSocketLib {}
#define CloseSocketLib {}
#endif

And then uses them in the code lookin’ something like this:

1
2
3
4
5

void main() {
  StartSocketLib;
  // do networky stuff
  CloseSocketLib;   
}

I’m reading through the example code and see something like “StartSocketLib;” on it’s own in a line of C++ and my brain halts. It’s not immediately obvious what that statement does: it should do absolutely nothing. Any variable or function placed like that evaluates to a NOP. I understand completely hiding OS-dependant details behind some pre-processor magic, but if you’re going to do that at least make the macro look like valid code.

Anyway, I bought the book for the ideas within it, and they’re worth what I spent on it, but the code drives me nuts, so it’s been slower going than I’d like it to be.

For debugging and safety’s sake, I throw an assert in the base class’ destructor that will fire if the object is freed with any references left. Nice for debugging, but it doesn’t work if I create a base-derived object on the stack. If I do, it’ll be created with one reference and be automatically destroyed as soon as the function ends, firing off the assert. I can’t just call release() on the object, ‘cause release() will try and free the object because its ref-count will drop to 0, but it can’t do that for an object created on the stack.

I like Objective-C and Java’s approach here better: you can’t create an object on the stack. You have to explicity allocate the thing, no magic.

I prefer Objective-C over C++ in general, but the lack of good tools outside of OS X have been keeping me from using it. I’m addicted to Visual Studio. :)

As an aside, I do understand that being able to create objects on the stack in C++ is what makes Resource Acquisition As Initialization (did I get that right?) work, but that’s really just a workaround for not having garbage collection anyway. Not that Objective-C has garbage collection (natively), but the omnipresent reference counting and autorelease pools do a good job of hiding it.

No TV; the stereo would be blaring Journey, or maybe some old U2; Santa Esmerelda would definitely have made an appearance. That’d be the night; good family, good music, good talk. Stories of all the silly, sometimes stupid, things we’d done as kids. A little bit of talk of the future; but probably not much. Just hanging out; enjoying each other’s company.

God, I miss those nights. Last night should have been just one of many more to come, but you’ve been gone a year and a half now. That loss feels nearly as raw now as it did when you passed away, and so I’m sitting crying at a car wash, writing you this letter.

All those stories of us as children, but to this day I don’t know much about your life before Becky was born. I know you worked from an early age, and that you were in the Marines, and I think you and Mom were married in Puerto Rico, but that’s it. I wish I’d asked when I had the chance. I wish I’d spent more of those nights hanging out with you, listening to your music. I wish I’d spent more days helping you at your store, or smeared with grease helping you out with your truck. I wish I’d not skipped family trips as I got older; I wish I’d gone to the family reunion. I wish I’d spent more time with you.

I’m sorry I went off and did my own thing so many times. I’m so very sorry I wasn’t there for you more while you were sick.

I’m getting married soon; I finally proposed to Jackie on her birthday last year. The date’s set for October 14th; there’s nothing special about the date (yet), it’s just a good time for it. We’ll have been together for 5 and a half years at that point. I know you liked her a lot, and it’s comforting to know that you’d approve of this.

Becky’s doing well too; she and Eric moved to a small town in Northern California that they love, at least when it stops raining. You have a new grand-daughter; Emma Rose Moses was born on April 1st last year. I haven’t gotten to spend enough time with her to know her yet, but just listening over the phone she sounds great. A bit better behaved than her sister, and so eager to catch up with your namesake. Kenna sounds like a cute little snot nowadays, but isn’t that what little girls are supposed to be like? They’re both slated to be flower-girls in my and Jackie’s wedding, and Becky a bridesmaid.

Daniel and Shawn are groomsmen, along with Dakota. I worry a bit about Daniel and Shawn; they could use having you around more than Becky and I. Daniel’s a bit self-destructive lately (well, more than usual), and Shawn’s still trying to find himself. They’ll both get along fine, and get to where they belong, I’m just afraid the trip will be harder than it has to be.

Daniel has 3 ‘79 Ford Trucks now, he’s nuts. One day he’s planning on making them into one perfect truck. I applaud the effort, and wish him luck in it, but it won’t be your truck. It’ll be his, and that’s cool. I’ll miss your truck, but it’s better than letting it fade away.

Shawn thrashed his Ranger, but that’s what we’ve all done. Daniel thrashed his Honda, I thrashed my Mazda, and Becky thrashed her Mustang. Shawn went and bought himself a brand-new F-150, and that fits the pattern too. He’s just working on an accelerated schedule. I’ll bet Dakota will get Daniel’s Ranger when he’s old enough, and I’m sure he’ll thrash it too.

I worry about Dakota most of all. He’s 11 now, living with his mom. That’s a good thing; he and Frida should be together. I know you wanted it that way. Daniel and Danielle shouldn’t have been responsible for him so early; a child is a difficult burden. They should be able to live their lives. That said, if he ever wants to live with me; I’ll take him in a heartbeat. Jackie and I will find some way to make things work if that ever happens.

But he needs you, Dad. He still has so much growing up to do, and there just isn’t anyone else out there as well qualified to show him how. There’s no role model good enough, certainly not me. I learned a lot from you, but I’m not ready yet.

Thank you Dad, for teaching me what it is to be a good person, and for being an incredible father. I hope to measure up to that standard one day, but I don’t yet. I’m too selfish.

I love you Dad, I don’t think I realized how much until you were gone. A year and a half now, and I miss you as much today as I did back then.

Jon

P.S. - I bought a motorcycle. Sorry.