McCabeism: turning noise into a thing of beauty

If you’ve seen any real­ity zoo/wild-life pro­gram you’ll rec­og­nize this. Five min­utes into the show you’re con­fronted with a wounded, mag­nif­i­cent ani­mal, held in cap­tiv­ity so its care­tak­ers can nur­ture and feed it. And inevitably, after three com­mer­cial breaks, they release it, teary-eyed, back into the wild. It’s a piv­otal moment that turns their leop­ard into anyone’s/no one’s leop­ard. And as much as they like to see the ani­mal run free, it hurts that only they know that that is the leop­ard that Bruce bottle-fed.

It’s sim­i­lar with code. The moment you choose to release an algo­rithm, a tech­nique, an idea, it’s no longer com­pletely yours. It’s out there, free for every­one to do as they like. And chances are that in the end only a few people’ll know that that is the clever algo­rithm that Bruce came up with. Not because of malig­nant thiev­ery, but because of Tumblr-like care­less attribution.

Anyway, most of us don’t have to worry about this, I gladly share it all, because real inno­va­tion that’s truly wor­thy of attri­bu­tion is rare. If some­one uses HE_Mesh, it’d be fun to be cred­ited for the hard work that went into it. But I don’t need credit for the things that are cre­ated with it. Many other tools exist and in any case, it’s an imple­men­ta­tion of an exist­ing data struc­ture. The thing is: any­one could’ve coded it…

There is how­ever an idea, an algo­rithm out there that was shared by its cre­ator Jonathan McCabe that is wor­thy of true attri­bu­tion, that falls out­side the realm of “any­one could’ve done it”. It’s been more than two years since I came across his multi-scale Turing pat­terns. They instantly intrigued me. And although I could recre­ate the gist of his images, I could never over­come the prac­ti­cal prob­lems. In fact, the code proved haz­ardous to the elderly, infants and preg­nant women. I thought my lack of numer­i­cal skill in tack­ling the huge equa­tions I ran into was the prob­lem. It was pon­der­ously slow and I sus­pected Jonathan had a secret lair packed with supercomputers.

Turns out I was being silly. An almost inci­den­tal post on Flickr revealed that Jonathan has a paper on his cyclic sym­met­ric multi-scale Turing patt.., what the hell, on his McCabeisms. And it’s full of DTC lines (A rarely needed acronym for “damn that’s clever”). Seems I wasn’t bark­ing up the wrong tree, I was in the wrong for­est, on the wrong con­ti­nent, on the wrong planet… As if that wasn’t enough, Jason Rampe pro­vides a blog post with use­ful point­ers in imple­ment­ing Jonathan’s idea. I say point­ers, it’s actu­ally more of a very elab­o­rate pseudocode than a blog post. So the McCabeism is out there, ready to be imple­mented by anyone.

So I did, in Processing and thanks to Jason, it only took a few hours. This sketch is my small con­tri­bu­tion to the free dis­tri­b­u­tion of Jonathan’s very, very clever idea. It con­tains the basics as explained in the Softology blog post. I’ve added no expla­na­tions of my own. Jonathan’s paper and Jason’s post are very clear and def­i­nitely worth reading.

Feel free to use it in your own explo­ration of McCabeism. There’s plenty of room for exper­i­men­ta­tion. Capture it, dis­sect it, change it, mutate it, (now that’s a wildlife show I’d like to see) and above all attribute it to Jonathan McCabe…






  1. What a won­der­ful post! Lots of laughs, and rev­er­ence ema­nat­ing for the DTCs of Jonathan McCabe. Very well writ­ten, and intrigu­ing to some­one who knows a lit­tle too much to be good for her. :o)

  2. thanks a ton, awe­some post :)

    is there a rea­son you wrote:

    for (int di = –radius; di =0)?([something]):0;

    instead of:

    for (int di = 0; di <= radius; di++) {
    total += [some­thing];

    this con­struct shows up a few times in TuringPattern

  3. hmm that com­ment got chomped by what­ever fil­ter is run­ning. but the ques­tion is basi­cally: the for loop runs from –radius to +radius, but only oper­ates on [0, +radius]. is there a rea­son for this?

  4. I have been fol­low­ing Jonathan on flickr for months. I knew he had some­thing when he posted his “bone art”. Way over my head, though. :)

  5. Kyle: you’re right of course but that was left in because it’s a sim­pli­fied imple­men­ta­tion meant for clar­ity. To avoid all kinds of bound­ary side-effects you’ll need some kind of padded array, e.g. when apply­ing rota­tion. In that case it’s use­ful to have a func­tion value(i,j) instead of plain value[i][j]. So I left in the strange –radius to radius pat­tern and plugged the hole with some gra­tu­itous ifs. Cheers!

  6. Wondering if it’s worth it to give it a try and imple­ment in AS3. Not sure how well can han­dle the inten­sive calculations.

  7. @esimov, give Pixelbender a try! I’m already work­ing on a GPU-accelerated ver­sion of Kyle’s awe­some pro­cess­ing sketch — not for Flash though.

  8. Pingback: Artists who use Processing « Digital Studio

  9. Pingback: Organic Turing Pattern |

  10. Pingback: Reshared post from John Baez « eripsa

  11. Pingback: Reaction-Diffusion Systems | Syntopia

Leave a Reply

Your email address will not be published.

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>