The first thing I tried out was simply running a filter kernel. Strangely enough, Apple’s documentation in that area is rather lacking – the assumption is always that you want to build the whole filter infrastructure with your kernel. Which I don’t – I want to get things going as soon as possible.

Well, after a bit of fiddling, here’s the necessary Python code:

kernelCode = """
kernel vec4 test(sampler src)
{
    return sample(src,samplerCoord(src))*0.5;
}
"""

def main(image):

    kernels = CIKernel.kernelsWithString_( kernelCode )
    kernel = kernels.objectAtIndex_(0)
    sampler = CISampler.samplerWithImage_( image )
    filter = CIFilter.alloc().init()

    return filter.apply_arguments_options_(kernel,[sampler,None],None)  

As an additional caveat, if you use Acorn versions older than 1.0.3, you need to attach a crop filter so the resulting image has extents. (Gus has added a fix for that in later releases)

extent = image.extent()

image = filter.apply_arguments_options_(kernel,[sampler,None],None)

# This part can be skipped with the latest Acorn - Gus added a fix. (Thanks, Gus!)
theCropVector = CIVector.vectorWithX_Y_Z_W_(0.0, 0.0, extent[1][0], extent[1][1])
cropFilter = CIFilter.filterWithName_("CICrop")
cropFilter.setValue_forKey_(theCropVector, "inputRectangle")
cropFilter.setValue_forKey_(image, "inputImage")
return cropFilter.valueForKey_("outputImage")

This gives you tremendous power, since it allows you to create ad-hoc filter effects – and all you have to do is change the python code on disc. Acorn will automatically use the latest version.

The only drawback here is that it’s hard to control filter parameters in a plug-in. You could write lots of U/I code – and you could do that in Python, yes – but Acorn already has a pretty fancy interface to filters. So instead, we’d like to register a core image filter via Plugins.

Can we do that? Technically, yes. PyObjC lets us subclass Objective C classes. Unfortunately, Python plugins get executed after the list of Core Image Filters is built – so our own filter will never show up in the filter menu. (The same is true for Objective-C Acorn plugins)

So – at least until Gus changes that – I’ll publish my filter kernels as Image Unit in Objective C. It’s a pain to create, compared to just wielding Python, though. (Technically, I could probably use the CGenericFilter in Jonathan Wights ToxicMedia framework. Haven’t gotten around to it yet. Please let me know if you try.)

I’d bug Gus about that, but I’ll wait till I can actually afford a license. I’ve soaked up quite a bit of his time already, and all on the trial version. Thank you for all the support, Gus – and I’ll be back

And because I’ve had so much fun developing filter kernels, here’s a Core Image plugin with the spotlight and reflection effect I used further up. Just drop it into ~/Library/Graphics/Image Units, and you have those two filters in the ‘Stylize’ category.

Update: Full source for Acorn Python plugin

That makes it even more important when companies get it right. One company that – in my opinion – got it totally right is SmugMug. I started a trial account with them about two weeks ago since I was exploring online photo services. I played around with it for a few days, and then got distracted.

They only give you a 14-day free period, but they’re smart enough to ask for feedback at the mid-term mark. And since I had some time, I actually wrote up my thoughts and concerns, including the reasons why I’d probably not switch over. To my surprise, I had an answer to this within 30 minutes – they addressed some of my concerns, showed me things I missed, and promised to take a few of my suggestions under consideration. That is quite impressive.

At that point, I was 50:50 on the switching thing. I really like SmugMug better than flickr. There are lots of features to tempt you – great galleries, awesome web interface, and the fact that the data is stored in several places simultaneously. (Hence you’ll lose pictures about never). Switching is always a hassle, so I thought I’d just let it lapse for now – especially since I just paid for a 2-year Pro account on flickr.

It got better, though. At the end of the 14 days, I got a second reminder – showing me where to sign up, or if I weren’t going to, asking if I’d share the reasons with them. I shared my reasoning with them, and I also mentioned I was working on an iPhoto plug-in for SmugMug. What can I say – I love playing with Web APIs, and I love plug-ins. Imagine my surprise when they immediately comp’ed me for a lifetime account. It’s their policy to give free accounts to all plug-in developers. Now that is really amazing. Not only the fact that they do it at all – the really mindblowing part is that it happens without any bureaucratic hassle.

A company that actively listens to you, answers your questions, and stands by its word – that would be enough for me to sign up with them even if I didn’t get the free account. So it’s time to move some pictures around…

Since it’s going to be rather technical, the details are hidden behind the cut…

Except this is OSX (Tiger in my case). So there is no Gems. Awesome. Before you head off to install it, be aware that the Darwin Ports version of it seems broken. The best way is going directly for the source.

curl -O http://rubyforge-files.ruby-forum.com/rubygems/rubygems-0.9.0.tgz
tar xzvf rubygems-0.9.0.tgz
cd rubygems-0.9.0
sudo /usr/bin/ruby setup.rb

OK, gems is installed. Next stop: simple-rss, a prerequisite for rubyrss. Conveniently enough it’s available as a gem. Except the rdocs are broken and cause gem to spit out a flood of error messages. Seems the developers know about it, too – but why rush a new gem just for a couple of warnings…. Anyways: disabling doc installation does that trick.

sudo gem install --no-ri --no-rdoc simple-rss-1.1.gem

That leaves the main package. And because it’s so much fun, it’s source-only, not packaged as a gem. Installation pains are to be expected, so I created a gem for you (and me) to use: rubyrss-1.1.gem

sudo install rubyrss-1.1.gem

And after all this, I’m finally ready to work on the main task. More on watching directory changes in a later post…

Tags: ruby osx rss

I’m not talking about constant reviews, like pair programming affords them. I’m talking about reviewing complete subsystems. Yes, theoretically they all get re-factored into excellence. Practically, it doesn’t hurt to take a step back and review the whole thing from time to time.

One method would be to sit down in front of the computer, look at the code, and discuss it. That leads to lots of good ideas, but it’s hard to keep track of all of them. You can add /// @TODO sections to the code, but those are hard to see, difficult to break out, and distracting – they are code comments, yet they have nothing to do with what the code does.

The old-fashioned method is to print out reams of paper, get everybody in a room, and have a go at it. Let’s skip the group review part, and why that’s a bad idea – even one on one, this is not a good practice. Not only is printing out all that paper environmentally unfriendly, it’s unmanageable. A weeks worth of code is easily 1000-1500 lines of code. If you can print it out at all, it probably requires landscape printing – which means you are now creating somewhere around 40-60 pages of printout.

And even more, I actually want to annotate code on my own and just send the notes to the owner. Putting a stack of paper on somebody’s desk is not the way to go.

Thankfully, we work in the Software Industry. We all have that problem. There must be tons of tools for this, right? Turns out the answer is “Not so”. After lots of Googling, there are very few links to share:

• Code Reviewer from Smart Bear Software. While it has a lot of features, its UI is rather outdated. The worst thing for me – the notes don’t show up in the code. Right behind that the fact that it’s high-process. Complete with audit trails, rejection/approval of check-ins, etc. Add to that a price of $350 per seat.

• Let’s turn to open source, then: CodeStriker is a web-based solution that does allow some commenting. But again, no inline-view of the comment, and a clunky interface.

• Finally, Microsoft offers the source to an annotation plug-in for Visual Studio. Still no inline annotation view, though.

After much searching, enter an unlikely knight: MS Word does almost exactly what I want to do. Just take your source from your IDE, complete with all the syntax highlighting. Copy it into a word file, turn the orientation to landscape. And voila – annotations like I want them. Now if somebody could put that in the IDE!

Tags: software development, tools, code review.