The Axis of Eval: What’s a condition system and why do you want one?.

I like the approach – it just reads a shell transcript and runs the commands it finds. If the output doesn’t match, it shows you a diff. It’s kind of like doctest.

It looks refreshingly simple to get started with, something that so many other test frameworks fail horribly at.

A while ago, I wrote something similar for work. After trying and failing to find a testing framework that wasn’t over-engineered, I wrote a script that looks in ./test/, and runs every file named whatever.test, and compares output to files whatever.test.stdout and whatever.test.stderr, if they exist. If not, it just uses the return value to determine success.

I loved how easy it was to add a test. Just write a script! There is no step two.

(cram found via Titus Brown )

It’s fascinating to me how often you hear about these overnight successes that took years to develop and were canceled, given up for dead, etc. many times.

I remember hearing similar stories about Self and Erlang at HOPL-3, the History of Programming Languages conference. Maybe you shouldn’t bet on the success of a new language unless it’s been cancelled or abandoned at least once?

Of these, the only one that’s polished enough to lure me away from emacs and seems to support my favorite mode of working is Cornerstone, and it still gets it a little wrong.

I like to write log comments while looking at (and scrolling through) the diffs for the files I’m committing. This means I want a text field for writing log comments on the same screen as the diffs, that isn’t modal, and doesn’t stop me from moving around between multiple diffs.

As far as I could tell, I couldn’t get the comment field and the diff display shown together in Versions, and while I could in ZigVersion, that app had a subpar diff display and lacked polish overall, missing key shortcuts where I’d expect them, for instance. Cornerstone almost lets me do what I want, but it displays the comment field in a modal sheet, so I have to cancel to change which diff I’m looking at.

This is easy in emacs, but I like a nicer diff GUI. Am I just missing something? This feels like a natural workflow, so it seems strange that no clients support it well.

The most recent version of iCal decided that events are write-once-read-many as well. You now have to use cmd-E to get into edit mode, while cmd-I just gives you a small display mode.

I’m mostly OK with that, although I find I edit events about as often as I look at their info windows – after editing I usually just deal with alarms, not the events themselves. The casual glance at the time and title is always enough – I think either you’re looking at the time and title or you’re editing. I don’t see the appeal in the new ‘info-only’ mode (if it’s actually new – it seems new.)

However, the change does highlight the jumble of editable text fields and text-like fields in the edit window:

The “Add Attendees” link and the “None” placeholder for url act the same – you click on them, and enter text. One’s a link and one’s mute gray text. Why? For my part, I think the gray text is too understated, and the link is too garish.

There are other differences: you can tab to the “url” field, but you can’t tab to “attendees”… until you add one, then you can. Once you click on either of them, the url field pops up a plain white raised NSTextField, but the attendees field is sunken and translucent, apparently an NSTokenField?

Both of the blue links could also be buttons. I’m still not completely sold on replacing buttons with links, but I can understand the trend. I think a small plus-sign button would be fine for “Add File”, though, and “Attendees” ought to be a text field. Why force the user to use the mouse when adding data to an event?

All in all, I think the “Add Attendees” link/field is pretty strange. I’m curious if I missing a precedent somewhere.

The latest version of PyObjC is 2.0, it’s installed by default on OS X 10.5, and XCode now includes templates for starting a PyObjC project. There’s even code autocomplete in XCode for PyObjC and IB integration, so aside from some smart-indenting issues, writing PyObjC in XCode is almost as natural as writing in ObjC.

I thought I’d post a few nice shortcuts and tips here.

You can use tuples for NSRect/Range/Point, for instance, this -

r = NSInsetRect(((0, 0) ,
                 (100, 100)),
                10, 10)

creates this NSRect -

NSRect origin=<nspoint x=10.0
                       y=10.0>
       size=<nssize width=80.0
                   height=80.0>>

Passing python arrays as NSArray instances (and dictionaries as NSDictionaries) works great, but sometimes you need to pass a C array. The Python ‘array’ module handles that nicely:

import array
g = NSGradient.alloc().
   initWithColors_locations_colorSpace_(
    [NSColor.whiteColor(),
     NSColor.blackColor()], <br/>
    array.array('f', [0.0, 1.0]),
    NSColorSpace.deviceRGBColorSpace())

ObjC selectors are just python strings in PyObjC.

defNC.addObserver_selector_name_object_(self,
  'windowDidResize:',
  NSWindowDidResizeNotification,
  self)
# or
self.performSelectorOnMainThread_withObject_waitUntilDone_('doIt:', None, False)
# or
if o.respondsToSelector_("fun:"): return o.fun_(a)

Finally, something that comes in handy when working with KVC, the ‘_’ method now defined on NSObjects in PyObjC:

o = <some ObjC object>
print o._.myKey
o._.myKey = 44
# is equivalent to:
print o.valueForKey_('myKey')
o.setValue_forKey_(44, 'myKey')

That last example is straight from the NEWS page, where lots of other useful info can be found.

I give paper sections and important emails a while to sit after I write them, and they always benefit from another look with fresh eyes. I think that doing this with code is worth thinking about.

Once you get a piece of code to the point where you believe it works – it’s passing its tests – go back over it and edit it. That is, go back and edit it for clarity, flow, and style. Just as if it were an essay.

This is particularly important for tests. If a test fails, it should tell a clear story that explains exactly what failed, and what it was expecting.

Things to consider editing out are vague variable or function names, and non-idiomatic shortcuts. Control flow can get tangled when working out a solution. Make it obvious. One-liners often don’t tell the full story. When you come back to a piece of code, you know the chase. It’s the first loose thread of a bug, a failed test, or an occurrence of a symbol you need to refactor. What you need is the story around it, and solid code will fill that in.

You can learn this by sharing your code or by waiting a while and reading it over again. It’s easier said than done – I don’t always do it, but I do know: an editing pass can do you good.

Something to think about: would a professional code editor help or hurt in the long run?

A while back, we had some code that was checking errno, then using the NSLocalizedString macro to get a localized error message, but it checked errno again later. Only the app isn’t localized yet. There’s no Localizable.strings file, so when NSBundle -localizedStringForKey gets called, even though it fails gracefully, it still ends up setting errno to “ENOENT”, or “file not found”.

So the lesson is – in case you’re seeing weird behavior where errno is changing after you check it, make sure you’re not using any system calls that might set it.

I’d like a social links site for software professionals on the Mac – does one exist?

Or am I missing the point of these sites, and there’s a feature in each of them to get only the links I want?

I’m curious – how do you get your mac-related links?

Update: From the comments and some emails, I heard three main ways. A few people just rely on the feeds they check regularly, trusting that if something’s interesting enough, eventually someone they read will post about it. This was basically my strategy.

A few other people plugged Scott Stevenson’s Cocoablogs.com, which I remember seeing a while back but overlooked when I wrote this post. He’s doing a good job of collecting interesting links and highlighting blogs you might want to check out – keep an eye on that site. To paraphrase Scott, he wants cocoablogs to be the ‘anti-digg’, a site where you can guarantee someone actually read the article before they recommend it to you. I’d say that’s a good idea – I don’t have patience for mob voting.

Finally, another suggestion was to follow the ‘cocoa’ tag on del.icio.us, something else I should have thought of – this is nice and social like digg and reddit, but it seems less likely that someone will tag an article they haven’t read, so I think it’s a stronger vote.

Thanks, everyone, for the suggestions!

If any area mac devs are meeting up around then, drop me a note.

I wonder if we’ll know anything by then about developing for the iPhone.