To push an onscreen button with a mouse involves several layers of indirection: you move your hand to push a device to move a tiny arrow across the screen until it is over the button, then you move your finger to push a physical button.

To push the same button on a touch screen, you just reach out and tap it.

This is the reason Apple uses the word “magical” in iPad marketing material. Being able to manipulate these virtual things directly, with your hands, is a big deal.

I don’t remember how long ago I had the idea for Fingerpaintball. There were a half dozen Breakout derivatives on the App Store already, but they all required the player to swipe a finger to move a paddle to hit the ball. While it works well with a joystick or a mouse, the interaction feels needlessly artificial on a touchscreen.

In October 2010 I started work on a Breakout-type game that would take advantage of iPad’s touchscreen. Instead of moving a virtual paddle, the player would draw a line, and the ball would bounce off those lines. The project was also a good opportunity for myself to re-learn OpenGL, since I hadn’t used it in so long.

Work slowed in November, due to demands from a part-time tech support role. It all but stopped in December, due to family obligations involving a trip halfway around the world. In January and February I was busy with client work, and Fingerpaintball was firmly on the back burner.

One does not usually need to register an app with iTunes until you are ready to upload a finished binary, but certain functionality, such as Game Center and In-App Purchases, require that you register the app in order to test it. Registering your app reserves the name you choose, but it also starts a countdown: if you don’t upload a binary within 120 days, the registration will be deleted and you won’t be able to use the name any more.

So in mid-February I received a warning: if I didn’t ship by March 17, I’d lose the name Fingerpaintball. Other developers on iphonesb advised me to simply delete it myself to avoid the penalty, re-registering it later when I was ready to finish the app. Ignoring them, I decided to use the deadline as motivation to finish the damn thing. Real artists ship.

It wasn’t until March 11 that I had time to work on the game again. I originally had a sizable list of things that “needed” to be in the 1.0 release, but with only a week remaining, I quickly learned what was really essential and what was not. For example, my intention from the start was to release the game under a fremium model: free to play the first few levels, pay to play the rest. Designing all the levels and implementing In-App Purchase was therefore necessary for 1.0, until I realized it wasn’t.

The advanced levels and the purchasing could wait for a later release. Bonuses could also wait. Multiball could wait. Sound effects could wait. It turns out that, when a hard deadline is approaching, a lot of things I thought were necessary could wait.

I thought I understood the idea that You Should Be Embarrassed By Your 1.0, but I didn’t really understand until now. In the past I would write what I believed to be a minimal feature list, and as I worked, adjust the release date accordingly. Now I see I had it backwards: I should have been picking a release date, then trimming feature list as I go.

So far there are two reviews on the U.S. App Store and they both basically say the same thing: a good concept but kind of boring to play. I tend to agree. I am embarrassed by Fingerpaintball in its current form. The parts that are there work well, but it’s just not enough.

I wonder, though, if iterative development applies to games. Changing the interface of a utility doesn’t have the same implications as changing the rules of a game. If people are competing via a leaderboard, an update can create an uneven playing field. But these are not insurmountable problems: new leaderboards can be created, or people can simply deal with it. World of Warcraft has an enormously sophisticated set of rules that has changed several times over its lifetime; if Blizzard can find a way to manage, so can I.

If you have an iPad, install Fingerpaintball and tell me what you think. Then stay tuned: I don’t intend to stay embarrassed for too long.

I recently moved into a new building with a washer and dryer in the basement. At midnight, I loaded my clothes into the washer, then returned to my apartment to wait. (Why I am so ridiculous as to start doing my laundry at midnight is outside the scope of this discussion.) I was reading, it was hot and radiators are not adjustable, so I removed my hoodie. My iPhone timer went off, so I picked it up, walked downstairs, moved my clothes to the dryer, walked back upstairs, then realized my keys were in the pocket of the hoodie on the other side of the door.

I am by no means a carefree sort of person. I am constantly worried about something. If there is nothing to worry about I will find something. I almost never lose my keys or wallet because I (usually) check my pockets several times before leaving a place. This is the sort of situation that could easily make a person like me flip out.

But I did not flip out.

I did not flip out because, about four years ago, I took an improv class. If you’ve heard Stephen Colbert’s commencement address to Knox College, you may be expecting me to describe how I used the power of “yes-and” to get back into my apartment. But the specifics of improv didn’t really have anything to do with it.

I didn’t really matter that the class was an improv class. And it also didn’t matter that I had taken that class. What mattered is that I socialized with people in that class, and took the next class, and made friends, and took more classes with friends, and assembled performing groups with friends, and even though I don’t perform as much as I did a year ago, I have a significant number of real friends.

So at the moment I realized I had locked myself out of my apartment, I didn’t panic because I knew I wouldn’t have to sleep on the floor or be extorted by a locksmith. I used my phone to tweet my predicament and within minutes two friends had offered me space on their sofas for the night.

If nobody had replied, there were a dozen people I could call (although I’d feel pretty terrible about waking them up). If they didn’t pick up, I still could have walked to the theatre or designated watering hole (uncomfortably in my socks, but do-able) and probably found somebody to help me out.

Websites like Twitter and Facebook are called “social networks” but that’s not what they are. They are models of social networks or tools to communicate within social networks, but without an underlying social network they are frivolous.

You want to test it before you upload to your production server, but your staging server has a different URL (obviously).

An easy trick is to use curl, manually setting the Host: header to simulate access through different URLs. For example, assume your test server is at IP address 1.2.3.4 and you want to make sure that example.com redirects to www.example.com. Type this:

curl --head --header "Host: example.com" http://1.2.3.4/

The –head option fetches only the headers. The –header option spoofs the Host: header with the value that would have been sent by a browser accessing your production site.

If your .htaccess is correct, you should get output like this:

HTTP/1.1 301 Moved Permanently
Date: Wed, 02 Feb 2011 18:47:54 GMT
Server: Apache/2.2.14
Location: http://www.example.com/

If the HTTP code on the first line is 301 and you have a Location field with the expected URL, it worked!

If you see “HTTP/1.1 200 OK” then the server just served up a regular page. If you see “HTTP/1.1 500 Internal Server Error” then something went horribly wrong.

Armed with this knowledge, a clever person could write a script to automate these tests, confirming that all the redirects work as expected before deploying the site.

This is the story of how I used VirtualBox to set up a Windows 7 guest on a Mac OS X host. Lots of people have done this. The reason I feel my story is compelling enough to tell is that, rather than using a single file to act as a virtual hard disk, I am using an actual hard disk, connected to my Mac via FireWire.

Why do this?

• Performance. Giving your virtual machine it’s own dedicated hard disk means it isn’t competing with the host machine for access. I haven’t run tests, and the USB or FireWire bottleneck may compromises guest performance, but my inner engineer would rather have a slower guest than a slower guest and host.
• Backup. A virtual hard disk is a large, frequently changing file. Most backup software, such as Time Machine, doesn’t work well with these.
• Portability. To use the virtual machine on a second computer, all I need to do is copy the settings, only a few kilobytes of data. Then all I have to do is plug the external disk into whatever computer I feel like using that day.
• Access. Instead of being locked away in a virtual hard disk file, my files are accessible to any computer that I can plug the drive into.

Now that I have convinced you this is worth the hassle, I will describe the details of the hassle.

Warning: the procedure below is not for the faint of heart. If you are uncomfortable at a command line, you may want to wait for software to support this in a more graceful manner.

Install VirtualBox

On Mac OS X you have three options (that I am aware of): Parallels Desktop, VMware Fusion, and VirtualBox. I used VirtualBox because it is free and I am a cheapskate. Parallels and VMware are very reasonably priced, and supposedly offer better performance, but my needs are modest and VirtualBox is pretty good.

Download VirtualBox and follow the installation instructions, etc. Don’t create your virtual machine just yet. Note to people of the future: 4.0.2 was the latest available version at the time of writing.

Create Virtual Disk File

Although your virtual machine will be using an actual hard disk, you still need to make a file that tells VirtualBox how to access the device. You can’t do this through the graphical interface, so you must drop down to the command line. Connect your disk and open a Terminal window. Then type:

diskutil list

You should see some output that looks like this:

/dev/disk0
   #:                       TYPE NAME                    SIZE       IDENTIFIER
   0:      GUID_partition_scheme                        *250.1 GB   disk0
   1:                        EFI                         209.7 MB   disk0s1
   2:                  Apple_HFS Macintosh HD            215.8 GB   disk0s2
   3:       Microsoft Basic Data BOOTCAMP                33.9 GB    disk0s3
/dev/disk1
   #:                       TYPE NAME                    SIZE       IDENTIFIER
   0:     Apple_partition_scheme                        *2.2 TB     disk1
   1:        Apple_partition_map                         32.3 KB    disk1s1
   2:                  Apple_HFS Drobo                   2.2 TB     disk1s3
/dev/disk2
   #:                       TYPE NAME                    SIZE       IDENTIFIER
   0:     Apple_partition_scheme                        *10.8 GB    disk2
   1:        Apple_partition_map                         32.3 KB    disk2s1
   2:                 Apple_HFSX benzado                 10.8 GB    disk2s2
/dev/disk4
   #:                       TYPE NAME                    SIZE       IDENTIFIER
   0:     FDisk_partition_scheme                        *60.0 GB    disk4

From this list, you need to identify which disk is the one you want to install onto. In my case, it’s the last one, disk4. I wish I could tell you exactly what to look for, but at this point I don’t know what’s on your disk, if it’s been formatted, etc. If you’re unsure, look for a number in the size column that matches the size of the drive.

Now for some harsh reality: Mac OS X assigns these disk numbers on a first-connected, first-served basis. In my case, the internal hard drive is disk0 and my Drobo is disk1. When I log in, Finder mounts my iDisk, so that’s disk2. At some point I downloaded and mounted a disk image to install some software, it was disk3. Then I connected the external drive, disk4. Finally, I ejected the disk image, which is why disk3 does not appear in the list above.

Our problem is that VirtualBox needs a disk identifier, but the identifier depends on when we plugged the drive in. The least painful way to deal with this problem is to create a symbolic link to the device identifier, and tell VirtualBox to use that. If the external disk’s identifier has changed, all we need to do is update the symbolic link. Let’s do that.

Switch to the directory where VirtualBox stores it’s hard disk files:

cd ~/Library/VirtualBox/HardDisks/

Create a link to the device we noted earlier:

ln -s /dev/disk4 ExternalDiskDeviceLink

Create the virtual disk file:

VBoxManage internalcommands createrawvmdk -filename ExternalDisk.vmdk -rawdisk $PWD/ExternalDiskDeviceLink

This creates a virtual disk file named ExternalDisk.vmdk which refers to the link ExternalDiskDeviceLink, which in turn points to the device /dev/disk4.

Whenever you need to point to a new device, update the symbolic link file:

ln -s /dev/disk3 ~/Library/VirtualBox/HardDisks/ExternalDiskDeviceLink

You may be wondering, why not just use VBoxManage to create a bunch of the vmdk files, and switch between those? You could do that, but each time you create a file, it is assigned a UUID which is apparently visible to the guest OS. Microsoft Office, for example, believes it has been copied to a new computer if this UUID changes, forcing you to reactivate your legally obtained copy by telephone.

Also, clicking around in VirtualBox to change the disk file each time would get annoying (to me) fast.

Configure a Virtual Machine

Launch VirtualBox and create a new virtual machine. The prompts are fairly straightforward, I won’t explain them all. When it asks you to select a virtual hard disk, select Use existing hard disk and then click the tiny folder icon to select the ExternalDisk.vmdk file you created earlier.

The guest and the host cannot use the external disk at the same time, so if the disk has been mounted on the host, make sure to eject it before you try to start the virtual machine. If you don’t, VirtualBox will lambast you with a cryptic, angry error message containing the word BUSY.

(If you get a different error message containing the word UNSUPPORTED, try changing the configuration so that the disk is connected to a virtual IDE controller rather than a virtual SATA controller.)

Once the VM is running, you can install Windows 7 (or whatever other OS you like). Allow the installer to partition and format the external drive.

Prevent the Drive from Auto-mounting

Even though I would eject the drives before starting the VM, Mac OS X would mount them again as soon as the VM shut down. This was annoying.

Then at some point I noticed Mac OS X mounted the drives while the virtual machine was running. This caused the VM to lock up and was generally horrible. So even though I was good about unmounting the drives before starting the VM, it is absolutely necessary to prevent Mac OS X from auto-mounting the drives.

If it’s running, shut down the VM. Let the drives mount automatically or use Disk Utility to mount them. Then open a Terminal window and type:

diskutil list

Here is the part of the output we’re interested in:

/dev/disk4
   #:                       TYPE NAME                    SIZE       IDENTIFIER
   0:     FDisk_partition_scheme                        *60.0 GB    disk4
   1:               Windows_NTFS System Reserved         104.9 MB   disk4s1
   2:               Windows_NTFS Homunculus Brain        59.9 GB    disk4s2

Windows has created two partitions; we need to make sure they don’t mount. We do this by listing them in the system’s fstab file. We can identify disks by label (name) or UUID. It’s better to use the UUID if we can, since it’s easy to change a disk’s label but impossible (well, very difficult) to change it’s UUID. Unfortunately, some partitions don’t appear to have one.

Find out if each partition has a UUID:

diskutil info disk4s1

Look for a line like:

   Volume UUID:              FB4E2CC6-36EF-41E1-9E41-D6E0D932F2EB

Make a note of the UUID; if it doesn’t have one, note the Volume Name instead. Repeat for disk4s2 and so on. Now create a file at /etc/fstab (you need root privileges to do so) and add the following lines. (If the file already exists, you can just add these lines to the end.)

# identifier, mount point, fs type, options
LABEL=System\040Reserved  none  ntfs  ro,noauto
UUID=FB4E2CC6-36EF-41E1-9E41-D6E0D932F2EB  none  ntfs  ro,noauto

In my case, “System Reserved” did not have a UUID, so I identified it by label, using \040 to represent the space. I’m not too worried about it, since its label is unlikely to change. The main partition’s name, other the other hand, can be changed by clicking around within Windows, so I’ve copied the UUID from above. You should copy the UUID from your system and not the one from this web page.

Anyway, that “noauto” keyword on the end of the line is what prevents Mac OS X from mounting the disk when you plug the drive in.

Test it by ejecting the disks, unplugging the drive, then plugging it back in. If nothing happens, you’ve succeeded!

If you ever want to mount the disks manually (perhaps to copy a file without booting up your VM), use Disk Utility.

Congratulate yourself

You have done it: a virtual machine that boots from an actual hard disk.

These instructions are based on my faulty memory of what worked for me on my computer. If you run into problems, leave a comment and let me know, but I can’t guarantee I can help you.

There is definitely room for improvement here. An enterprising sort of person could probably write a script or application that automatically updates the symbolic link before starting the VM.

This is a scanner for office settings, where people are usually interested in creating PDF files from legal documents, and don’t want high resolution uncompressed black and white images. So every time somebody needs to scan anything, they must change the format from TIFF to PDF. This is crazy.

For the longest time, I didn’t think there was a way to change the default. Turns out I was wrong. I don’t think you will blame me for thinking it was impossible, though. Inspired by instructions for other models of Canon equipment, I gave it another try. Here’s how to do it:

1. “Additional Func.”
2. “Communications Settings”
3. “Common Settings”
4. “TX Settings”
5. “Change Send Func. Mode”
6. “Register”
7. Now you see a menu of scanning options, including an item for Color/File Format. Change it to whatever you like.
8. Select “Register” and then “Done” the appropriate number of times to get back to the main menu.
9. The next time you scan, you may be presented with the old defaults, making you think the change did not take hold. If you back out to the main menu and then try to scan again, you may find that the change has taken effect.

I mean, seriously? Communications settings?

Here’s what worked for me: I was born in 1980 to parents who were successful enough to afford a home computer and also easygoing enough to let their children play with it. The timing was fortuitous because it meant I had plenty of time to learn and — I think this is key — computers of the late 80s/early 90s were easier to learn about. Since then all I’ve had to do is keep up.

In other words, what worked for me definitely won’t work for you.

First of all, you should know that programming is not the same as computer science. It’s like the difference between doing math and being a mathematician. Or between gardening and being a plant biologist. I already knew how to program long before I got to college. Most students who enter C.S. programs do, in fact, which is why college programming classes are usually terrible. Don’t bother taking a class, unless you know someone who can vouch for it.

Second, you should distinguish programming (the skill) from learning a specific programming language, like Java or C++ or MATLAB. Different languages are suited for different tasks, but regardless of your ultimate goal, your first task is to learn programming. For example, if you want to write an iPhone app, you must learn Objective-C, but if you know nothing about programming, it’s a terrible place to start.

The first computers I ever used had a built-in BASIC interpreter, and if you were a geek (which you were, because you had a computer in your home in 1989) you would buy magazines with program listings in the back and type them in. Even if you didn’t want to learn how to write programs, you could not help but be exposed to the process.

Since then, computers have become consumer products that do all sorts of useful things out of the box, no programming required. Also, graphical interfaces have completely replaced text-based command lines. That’s great news, unless you’re learning to program, because programming for a graphical user interface is hard.

When you write for a text-based system, your program starts executing at the top, and continues line by line, until it gets to the end. This is relatively easy for a beginner to understand. When you write for a graphical system (desktop or web), your program is responding to events, and different functions are called in response to user actions. Writing programs for an event-based environment is a lot more complicated.

Why am I telling you this? Well, a lot of tutorials ignore or try to gloss over this difference. They believe you will be more excited to draw circles on the screen than to print text in a terminal, so they drop you in the event-based world without a good explanation of what is going on, telling you stick your code here and not worry about the rest of it. But the minute you start experimenting your program locks up and you don’t know why. A good tutorial will teach you programming skills in a text-based environment.

OK, so those are some of my opinions on learning to program, from the perspective of someone who likes to write programs. But you aren’t specifically interested in becoming a programmer, you just want to learn enough to mine data from websites. So, if I haven’t scared you off, let’s talk about your specific case:

The good news is that you won’t need to learn any of that event-based graphical user interface stuff. And not in you-can-cut-corners way, but in a that-won’t-be-useful-for-the-task way.

Second, you will want a language that can deal with text easily, since you will eventually be downloading web pages and then parsing out the bits you are interested in.

Anything in the category of “scripting language” would fit the bill, and those are a good choice for learning general programming concepts, too. The big ones in that category are Python, Perl, and Ruby.

My advice: find a book that teaches programming using one of those languages. Preferably, a “Learn How to Program” book that happens to use one of them, as opposed to a “Learn Python/Perl/Ruby” book that claims to assume no prior knowledge is necessary.

I can’t recommend a specific book. Search Amazon and read the reviews or go to a bookstore and browse through the books. Even better: go to a bookstore and look up the Amazon reviews on your smartphone as you browse.

Once you pick a book, treat it like a college textbook and work through it. Do all the exercises. (Oh yeah, pick a book with exercises.) Wander off course and experiment on your own if you’re feeling bold, but if you get lost or stuck, go back to the book.

Oh, and sign up for an account at Stack Overflow. It’s a Q&A site for programmers. If you have a question, you can search there to see if it’s been answered, and if it hasn’t, you can ask it. (I’m happy to help, too, but I guarantee Stack Overflow will get you answers faster.)

Good luck! Let me know how it goes.

So… what do folks think about the app store? Good? Bad?

That was Wednesday, and the thread is still going on. The discussion has actually been pretty reasonable. Anyway, I just spent a while contributing the 137th message of the thread, and since I spent a lot of time on it, I thought I would reproduce it here.

On Oct 23, 2010, at 9:34 AM, Ken Aspeslagh wrote:

Unlikely? I disagree. As announced, the Mac App Store sets Mac apps moving in the direction of iPhone apps. Apple has set it in motion, moving in a direction, and it will continue on this course. Apple is genius when it comes to transitions. They know how to make a difficult plan, execute it incrementally over the course of years, and make each incremental announcement sound exciting. This is just the first step of a plan to completely revolutionize desktop computers, just as they forever revolutionized mobile phones.

You’re making an assumption that Apple has some grand vision of the future that they are steering everybody toward, whether we like it or not. Not just you. That idea is at the heart of a lot of the fatalistic comments about the App Store.

You could be right. But I think it’s a side effect of Apple’s secrecy that you never see how uncertain they are. Companies that talk about products in development can look clueless because you see them trying out different, possibly terrible ideas. Apple is very careful to hide their cards unless they think they have a winning hand. And even when they do, they still bet small.

One thing Apple does that is unusual for such a large company, is that when something isn’t working, they don’t double down like idiots. Consider Apple TV: when version 1.0 didn’t sell so well, they didn’t look for ways to “revise” the existing product into success. They more or less scrapped it and made a new product with the same name. If they had a “vision”, they were clearly willing to adjust it.

Remember the fat iPod nano? I think Jobs didn’t even show a picture of it during the touchscreen nano announcement. Now the nano is a tiny touchscreen. That’s nuts how different that is from the previous one! Is it selling well? I don’t know, but if it isn’t, Apple will be sure to go back to a clickwheel nano next year. Just like they put buttons back on the iPod shuffle this year.

So here’s the deal with the Mac App Store. They saw that people liked buying apps on their phones, because the environment made it easy and safe. So they are trying to bring that to the Mac. I think it could go a number of ways, and I don’t think Apple has decided which way yet. I think they are going to respond to the market.

Here’s something to consider: the Mac App Store might actually lead to a less restrictive environment on iOS devices. How? Well, the argument for requiring code to be signed by Apple is that it makes supporting a product much easier. If the Mac App Store leads to a drastic reduction in Mac software support issues, even while allowing users to install their own software, that makes the case that maybe the iOS restriction on unsigned code can be relaxed.

Or maybe the other thing will happen, where all software must come from Apple.

Who knows? Nobody does.

The point is, saying that Apple has a plan for where this is going to go is like saying that the Steelers have a plan to win the Superbowl. Sure, they have a plan, but ultimately they have to react to what happens in the real world. They are not all-powerful. They just good at looking like they are.

So, while I accept that a horrible totalitarian future is possible, if it comes to pass it will be because that’s what the market demanded. And anyone who “knew it all along” will have as much right to brag as somebody who bet on the winning Superbowl team.

Go Steelers!

Let’s also say you have a source file of SQL commands, checked into source control, that you use to generate the database file. You could manually generate the database file and add it to your project, but you want a clean build process, with no steps to remember between checkout and build.

The right way to accomplish this is by adding a Run Script Build Phase to your target, so that when you build, Xcode creates the database file for you.

Xcode lets you specify the Input Files the script depends on and the Output Files it generates, so that it can examine modification dates and determine if the script needs to be run at all. When you add a new Output File to the list, the default value is $(DERIVED_FILE_DIR)/myfile, which seems to be a pretty clear endorsement of that location as the place to store generated files.

So let’s say you write the script and save the database file to $(DERIVED_FILE_DIR)/Template.db. You add a reference to this file to your Xcode project (navigating to a DerivedSources folder somewhere within the Intermediate Build Files directory). When you build, Xcode generates your file (Run Script phase) then copies it into your app’s bundle (Copy Bundle Resources phase). Hooray!

Then you change the build configuration from Debug to Release, and it breaks. Why?

The problem is the file references. The DERIVED_FILE_DIR location depends on the current target and build configuration. When you switched from Debug to Release, the script dutifully generated a file in the correct location, but the file references are looking in the wrong place. The Debug location is hardcoded into the path.

Select any of the files and hit Cmd-I, and you’ll see a Path Type popup menu that tells Xcode how to resolve that file’s path. Here are all the options:

• Relative to Enclosing Group: this just passes the buck.
• Relative to Project: this is where your source files are stored.
• Absolute Path: this doesn’t even try.
• Relative to Build Product: this sounds promising, but Build Products are distinct from Intermediate Build Files, and we want the latter.
• Relative to Xcode folder: nope.
• Relative to Current SDK: of course not.

At this point, you could give up and modify your script to write the file directly into the app bundle. But that would be so dirty!

It turns out you are not limited to only those options. Additional source trees you define in Xcode Preferences will appear in that popup menu. Here’s what to do:

1. If you haven’t already, organize all the derived files into a DerivedSources group, and set the Path Type of each to be Relative to Enclosing Group. If done properly, the Path: field should contain only the file name. (If that’s not the case, click Choose… to select the file. If the file doesn’t exist, do a build to create it.)
2. Open Xcode Preferences and select Source Trees.
3. Add a new source tree, with Setting Name as DERIVED_FILE_DIR, Display Name as Derived Files, and Path as $(DERIVED_FILE_DIR).
4. Click OK.
5. In the project window, select the DerivedSources group and hit Cmd-I.
6. Change Path Type to Relative to Derived Files.
7. Unfortunately, the Xcode GUI is not able to resolve DERIVED_FILE_DIR properly; the Full Path will be missing the active target’s name. As a result, the path is invalid, and Xcode will fill in the Path field trying to find it’s way to a DerivedSources folder. We don’t want that, we want Path: to be None. I know of no way to do that within Xcode, so we’ll have to edit the project file. Take a deep breath.
8. Close Xcode.
9. Use a text editor to open the project.pbxproj file inside your Xcode project bundle.
10. Find the DerivedSources section. It will contain a few key-value pairs: isa, children, name, path, and sourceTree. Delete the path line and save the file.
11. Reopen your project file.

The group will appear in red, indicating that the Xcode GUI can’t find them, but when you perform a build Xcode will look in the right places and use the correct files.

I figured this out by experimenting on my own, so it’s possible that these instructions won’t work for you, or that there’s a better way to do this. If that’s the case, let me know, and I’ll update this post.

Images on this blog had been broken ever since I migrated to NearlyFreeSpeech.NET several months ago. I took some time today to fix them and tie up some other loose ends. I learned that PHP’s safe mode (as implemented by NSFN, anyway) won’t allow a file to be created unless the group of the destination directory and the script being executed match. Once I chgrp‘d everything to the “web” group, things I couldn’t get working before, like WP-Super-Cache, started working again.

I use rsync to update my website, and it would be great if it could take care of setting the owner and group appropriately on files it copied to the web server. Unfortunately, rsync will only try to find a group with the same name on both systems, or ignore the group it entirely. There doesn’t seem to be a way to provide your own mapping to rsync, and tell it that the local group “staff” should be mapped to group “web” on the remote system.

Just in case there were some rsync secrets I didn’t know about, I went searching on Super User, and that’s where I browsed my way to this question: Stop my mac from Sleeping whilst a bash script is running and then allow it to sleep as normal when it’s done?

The lone answer to the question merely suggested reading the manual page for pmset. I figured I could offer the world something more helpful than RTFM, so I took a look at it myself. At first I thought I’d have to do a lot of work to figure out the current power settings, save them, disable sleep, do whatever work the Mac needs to stay awake for, then finally restore the saved settings. That would have been especially difficult since pmset’s output isn’t designed for parsing.

However, it turns out pmset has a mode designed just for this situation. It’s barely explained in the manual, but if you call pmset noidle, sleep will be disable for as long as the process is alive. So all you need to do is something like this:

# start background process to disable sleep
pmset noidle &
# save its process ID so we can terminate it later
PMSETPID=$!
 
...have your fun here...
 
# kill pmset so the computer can sleep if it wants to
kill $PMSETPID

It would be nice if my write up would improve my Super User Reputation, but considering that the question is viewed approximately 0.37 times per day, I’m not holding my breath.

I live in New York City. When I used to commute to an office, paying for a 30-day Unlimited Ride card was a no-brainer. But once I started working from home, I noticed there were days when I didn’t ride the train at all. I began to wonder if I would be better off with a pay-per-ride card, and that’s when I wrote MetroCost.

From last September through March, I have spent $498 on MetroCards: initially unlimited, then pay-per-ride, then recently switching back to unlimited. Each time I had to renew my card, I followed MetroCost’s recommendation. The result is that I spent an average of $83/month, a savings of $6/month over the MTA’s 30-day Unlimited Ride card. That’s $72 a year!

I could say that MetroCost pays for itself, but since it is now completely free, what’s really happening is that I am giving you money. How about that?

Two more things:

• MetroCost was designed with New York City in mind, but it is customizable. So, if your public transit system operates on a single fare-per-ride system, you can use it, too. San Francisco and Atlanta are supported out of the box. In a future update I may add support for Boston or even London (if you stay within one zone).
• I am by no means abandoning this app. I just decided that I didn’t want to deal with the difficulty of trying to market a product designed for people who are trying to save money. I have a few ideas for updates, when I have the time.