One for the coders: I discovered CodeRunner by Nikolai Krill a few months back, and it’s proven to be very, very useful in the kind of work that I do. It allows you to test blocks of code and see the results quickly and easily. It has syntax highlighting and autocompletion, as well as the ability to handle a wide variety of languages.

CodeRunner handles AppleScript, C, C++, Java, JavaScript (Node.js), Objective-C, Perl, PHP, Python, Ruby and shell scripts. You can add your own languages, compilers/processors and syntaxes, too. The autocomplete libraries for each language are quite good (and very handy), and there are a good number of themes available for syntax highlighting (including my favorite, Twilight). It has auto-pairing and commands for wrapping code in a variety of paired characters, as well as a great set of code-editing tools. You can even pick between indenting with spaces or tabs and set the tab/space width, making it easy to match the code indentation to the settings of the main app you’re coding in.

CodeRunner can also handle code that requires input at runtime, providing a field for passing parameters and input to your functions as needed. In short, it does just about everything I could ask a code-testing application to do.

There are free apps for testing code, but very few that can handle multiple languages and none that I know of which can handle everything that CodeRunner does. If you code in more than one language, CodeRunner is worth every bit of its $4.99 price. Go get it.

Nikolai also has a regular expression testing app in the Mac App Store called Patterns. I highly recommend it as well. The only issue I have with Patterns is that it doesn’t handle highlighting sub-matches, but for 90% of what I need it to do, it’s excellent.

Related posts:

1. App Review: LiveReload
2. iOS App Review: Reading List
3. iOS app review: Listary

Originally posted on BrettTerpstra.com at App Review: CodeRunner

It starts out with mdfind and all of the creative scripting you can do with it. You start finding batches of files with something in common and you do things with them or to them. It sounds genocidal; it’s not. It’s very productive after the initial script setup.

Take, for example, a little script I run to add thumbnails to weblocs I have laying around. It looks something like this:

mdfind -onlyin ~/Dropbox/Sync/Bookmark/ \
'(! ( ((kMDItemOMUserTags == "*donotthumbnail*"cd) \
|| (kOMUserTags == "*donotthumbnail*"cd) ) ) \
&& (kMDItemFSHasCustomIcon = "0") \
&& (kMDItemContentType == "*webloc*"cd))' | while read file; \
do /usr/local/bin/setWeblocThumb "$file" ; done

It’s a one-liner, you’d want to reassemble it to run it (remove the backslashes at the line ends and join them all together), but it uses mdfind to search my shared bookmarks folder for recent items which don’t already have a custom thumbnail, passes them to setWeblocThumb and processes them… one at a time. I know my machine and my bandwidth can handle more than that, but if the list is 50+ long, that’s a lot of processes doing some relatively intensive labor. It would grind my machine to a halt. Yes, I tried it just to be sure.

So I needed a way to throttle the number of simultaneous processes, and I know that someone out there must have long beat me to the solution. There it was: parallel. It’s a script you can download and make executable in your path, and then run it with a few parameters and a batch of files or arguments. It will keep your defined number of processes going until the job is done, but won’t let things get out of hand. You can add nice (man page) in each process if you need more cpu control over the process.

My new command looks like:

mdfind -onlyin /Users/ttscoff/Dropbox/Sync/Bookmark/ \
'(! ( ((kMDItemOMUserTags == "*donotthumbnail*"cd) \
|| (kOMUserTags == "*donotthumbnail*"cd) ) ) \
&& (kMDItemFSHasCustomIcon = "0") \
&& (kMDItemContentType == "*webloc*"cd))'| parallel -j 8 -r "/usr/local/bin/setWeblocThumb"

Seriously, if you’re doing anything in batch you should check Parallel out, or show me an even better one. Parallel made my morning, and by keeping CPU from maxing I actually got through some batches even faster. I’m sure there are other elegant ways of handling this. Let ‘em rip.

Related posts:

1. Geeklet: Top RAM Processes
2. Geeklet: Top CPU processes
3. A Bash function for Markdown bloggers

Originally posted on BrettTerpstra.com at Quick Tip: throttling parallel batch processes in Terminal

Another post, quickly and with less explanation…

The fact that Evernote processes HTML so much better than it does plain or rich text got me thinking and tinkering. I use Markdown (actually, MultiMarkdown) constantly, and it does a great job of turning plain text into valid markup. With (Multi)Markdown, even plain text becomes HTML that–when imported into Evernote–retains most of its formatting. To answer your question, no, I’m not obsessed with Evernote, I’m obsessed with problems I think I could solve. It’s unhealthy.

Please note, this requires that you have Fletcher Penney’s MultiMarkdown installed in ~/Library/Application Support/MultiMarkdown, and that the Perl files (MultiMarkdown.pl and SmartyPants.pl) are located in a ‘bin’ subdirectory (which is the default install). If you don’t have MultiMarkdown, you should get it anyway (all the cool kids have it), so head over to the download page and grab a copy. Now, on with the show.

I set this up originally as a TextMate command, intending just to be able to clip code snippets and free-form text to Evernote without thinking too much about it. That worked well, so I modified it to work as a System Service. Specifically, a Snow Leopard service, but I’m providing the Ruby script here and it can be modified for any Mac setup you want.

While it will work just fine on plain text with no markup, it does have a couple of “special” features. If you start a line with a # and a space (e.g.: # This is my header), which is a Markdown convention for a first-level heading, it will use that as the title for the note and strip it out of the text in processing. It only uses the first one it finds, but it will strip out any first-level headers in the selection. I’ll probably modify that later, or just have it leave them in. Also, a line that begins with “tags:” followed by a space and a comma-separated list of words will be split up and used to tag the new note. This is also stripped before processing. It handles spaces in multi-word tags, and odd marks at the beginning or end of a tag, but only one punctuation character, and only at the beginning or end of a tag. The code follows…

Here’s the Ruby code, messy as it may be:

    #!/usr/bin/env ruby -rjcode -Ku
    # requires that MultiMarkdown be installed in ~/Library/Application Support/MultiMarkdown
    # That, or edit the script to point to yours :)

    ARGF.each do |f|
    input = f
    contents = ''
    tags = ''
    title = nil

    def e_as(str)
        str.to_s.gsub(/(?=["\\])/, '\\')
    end
    input.each_line { |line| 
      if line =~ /^# (.*?)/
        title = line[2..-1]
        break
      end
    }
    title = %x{date '+Clipped note: %A, %B %d, %Y at %l:%M %p'|tr -s " "} if title.nil?

    input.each_line { |line| 
      if line =~ /^[Tt]ags: /
        tags = line[5..-1].split(',').map {|tag| tag = tag.strip.gsub(/^(.)?\b|\b(.)?$/,"\\2\"\\1") }
        break
      end
    }

    IO.popen('"$HOME/Library/Application Support/MultiMarkdown/bin/MultiMarkdown.pl"|"$HOME/Library/Application Support/MultiMarkdown/bin/SmartyPants.pl"', "r+") do |io|
     input.each_line { |line| 
        io << line unless line =~ /^# |[Tt]ags\: /
     }; io.close_write
     io.each_line do |line|
       contents << line
     end
    end
    tags = " tags {#{tags.join(",")}}" unless tags.empty?
    %x{osascript -e 'tell application "Evernote" to create note with html "#{e_as contents}" title "#{title}" notebook "Unfiled"#{tags}'}
    end

You can create a System Service in Automator with it, set up a command in TextMate, or do whatever else you can think of. If you just want to download the service and try it out, I’ve made it available here. Unzip and copy it to ~/Library/Services (in your home folder). If you set it up as a System Service, assign a shortcut key in the Keyboard pane of System Preferences.

It does choke once in a while, apparently on Markdown-generated code snippets, but I haven’t quite narrowed down why, yet. I’ll update the code if I figure that one out. Overall, though, it makes pretty clippings and allows you to use some Markdown syntax to spice up your text without having to touch the (regrettably abominable) Evernote editor.

Related posts:

1. Taking the Markdown to Evernote service further
2. Evernote Site Memory tagger for WordPress
3. A Service for writing MultiMarkdown footnotes inline

Originally posted on BrettTerpstra.com at A better System Service for Evernote clipping — with MultiMarkdown

This is a stripped down version of a command I have in the TextMate bundle we use at TUAW. It allows you to select any basic numeric equation and evaluate it, replacing the selected text with the results. It will ignore your text if it contains anything but numbers and basic mathematical symbols. Sure, there are plenty of ways to do calculations in OS X (Spotlight, Launchbar, Quicksilver), but I’ve had more and more incidents lately where I just wanted to do quick calculations inline, so I whipped this up. A little explanation…

The service is built for Snow Leopard only, but I’m including the code here because it could be wrapped up in ThisService or Bellhop pretty quickly for Leopard. It’s built in Ruby and uses the eval function to process text such as 20*(3.5/2) and return the result. It will add commas to numbers longer than 3 digits, but I stripped out the part of the original command that trimmed decimal places; I figured the accuracy might be important and the results are easy to edit manually in this case. I also added a silly feature that I actually find quite useful: it evaluates +/- percentage strings, such as 23.99-15%, which I find most useful for calculating savings during sales or quickly handling markup or tax on services and goods. It can’t get too complex, but for most everyday purposes, it does a good job.

The code:

def ts( st )
  # Adds commas to longer numbers
  # Removes .00 left over from % calculations
  mynum = st.to_s.reverse.scan(/(?:\d*\.)?\d{1,3}-?/).join(',').reverse
  dec = mynum.split('.')
  return dec[0] if dec[1].to_i == 0
  mynum
end

ARGF.each do |f|
    # check if the text passed is actually an equation
    if f.match(/^[\%\$\d\*\/\+\-,\. \(\)]+$/)
        # add a preceding 0 to decimals passed for floating point calculation
        num = f.gsub(/(^|[^\d])(\.\d+)/,'\10\2')
        # convert basic percentage equations for eval
        num = num.gsub(/([\d\.]+)(?:\s+?)?([+-])(?:\s+?)?([\d\.]+)%([^\d]|$)/,'\1\2(\1*(\3.to_f * 0.01))\4')
        # process the result to add commas, trim unnecessary decimal places
        print ts(eval(num).to_s)
    # if it's not an equation, return the input (no effect)
    else
        print f
    end
end

You can download a ready-to-go Snow Leopard service, or build your own with the code above. Don’t forget to use the Keyboard preference panel to assign a keyboard shortcut to it (I’m using Control-Shift-=). I’d love to hear back if you find it useful!

Related posts:

1. Clippable to Evernote Snow Leopard Service
2. Updated: Songza Lucky Link Service
3. SMS from the command line with Google Voice

Originally posted on BrettTerpstra.com at A (fairly) simple equation evaluation service for Snow Leopard