The key to getting random values within a defined range is to first gather our values of interest in one container and then extract them randomly from the container and delete the item after it is selected. In our block dissolve, we will scale the individual grid items based on a simple timeline keyframe, so our container can simply be an increment counter of the number of values in the grid. Like so,

var gridArray = new Array();
var counter = 0;

for(x = 0; x < gridWidth; x++){
      for(y= 0; y < gridHeight; y++){
          gridArray.push(++counter);
      }
}

Later, when we need to randomize our values, we extract the numbers from the grid.

var random = Math.floor(Math.random() * gridArray.length);
var startTime = gridArray.splice(random, 1) *  (win.speed.value * .10);
var endTime  = startTime +  (win.speed.value * .10);
scaleProp.setValueAtTime(startTime, [0,0]);
scaleProp.setValueAtTime(endTime, [100,100]);

The splice Array method lets us extract the value from the array. The next time through we make the random values based on the length of the array, so that each time through the loop we are only pulling values for the remaining elements.

When I run the script, I get results like this

Because of the overhead of creating layers, this technique is especially useful in creating Gradient Wipes or Beauty/Matte passes. For example if we replace the above code with something like...

var startTime = (x + y) *  (win.speed.value * .10);
var endTime = startTime +  (win.speed.value * .10);
scaleProp.setValueAtTime(startTime, [0,0]);
scaleProp.setValueAtTime(endTime, [100,100]);

We then get this.

We can introduce some trig functions for some springy transitions, spirals etc. There are a lot of possibilities. Feel free to share some of your ideas and I'll put them up here.

Source JSX script

The idea of a pipeline is one of the trickier ideas to master for new users of image processing applications. In image processing each new operation like a blur, composite operation or color adjustment is applied and then passed to the next operation. In the example that Apple gives above, a Proc Amp operation applied late in the pipeline could boost the color levels outside of a safe range even though Broadcast Safe filter was applied in the stack. I’ve often found when you’ve got a visually unexpected output, moving the filter arrangement will restore some sanity to the expected output.

Additionally, as applications like After Effects transition to 32 bit float environments you’ll see additions to pipelines like HDR Compander which can compress and decompress the pixel pipeline to work with 8 and 16bit effects.

It is important to get a strong conceptual understanding of core concepts like image processing pipelines. These ideas become even more important with programs moving to 32 bit float color and using pixel-level operations via the GPU like in Apple’s Core Image. Finally, I really recommend that you keep up with what Stu Maschwitz posts at Prolost. He writes about really hard tech like color space and image processing but with attention to form and artistry I can only aspire to.

I have shot thousands of stills
that I am now wanting to make
a time lapse movie out of. Each
still is named with the date and time
it was taken. For example
0507270505011.jpg would have been
taken yy/mm/dd/hh/mm/ss/(camera ID).
...
is there a way to parse the filename
to convert it into something more
legible? So 0507230004461.jpg would
translate into July 23, 2005 - 12:10 AM?...

The more I thought about it, this is exactly the kind of task I’m hoping to cover here at Creative Workflow Hacks. So in addition to posting a usable solution at aenhancers I decided to do a tutorial here with the problem solving steps involved. You know, teach a guy to fish and all.

I’m also going to try something new here. From the feedback I’m getting from users, the skill level and interest in DIY varies a lot. Some of you are hoping for beginners tutorials, some are looking for more advanced ideas and inspiration, and some of you are looking for solutions that are already thought through where you can download a bit of software, do your work and forget about it. So, I’m going to try labeling categories with beginner, intermediate, advanced and shrinkwrapped (although not that much software is actually shrinkwrapped anymore) depending on the skill level and the degree of involvement necessary to get the solution working. Send some feedback if you find it useful or not.

Back to our date parsing problem. Like almost all computer problems, the key here is to break down the big problem into a series of smaller problems. Today we are going to write a function to do our bit of business and return the parsed date. A function allows us to organize these smaller tasks into one section of a program that does one function. Later, when we talk about Object Oriented Programming we will refer to a function as a method, but no matter which name is used they do similar things.

A function has a signature. It is all of the component parts of a function placed correctly so that the program interpreter will know what to do with the parts of the function. An interpreter is a program running behind the scenes that takes all the parts of the function and convert it it into instructions the computer and program will understand. If you type something the interpreter doesn’t understand you will get a syntax error that indicates you made a mistake.

In javascript, our function signature looks something like this:

function doSomething(withThis){
         return thisResult;
}

Javascript has it’s roots in a C style syntax. C is a programming language that has been around over 30 years, which is several centuries in programming dog years. Because it has been so popular for so long, a lot of programming languages (Java, C#, C++, Javascript, etc.) have adopted it’s syntax. Some of the notable features are the use of the ( ), { }, and ; characters.

The ; character is used to define the end of a statement. A statement corresponds to a declarative sentence in english. You tell the interpreter something about the value of something or how something corresponds to something else.
The parentheses characters are used to group an evaluation. When we are testing for a value we use parentheses. This is called a conditional.
The brace characters define a block of statements. It helps the interpreter understand the flow of your program. We’ll talk more about all of these ideas in just a bit.

So we’ll start with the function signature and intitial variables for our date parsing function.

var jpgName = '0507230004461.jpg';
var dateStringParsed;
dateStringParsed = parseDateString(jpgName);    

function parseDateString(jpgName){
   var evaluatedDateString = '';
   return evaluatedDateString;
}

First we set a variable for our jpeg name. A variable is a holder for our values. We can set values and manipulate values and keep them in a variable while we are doing so. Javascript is a typeless language. Meaning a variable can contain any kind of value. In this case it holds a string value of characters. Javascript has functions to convert between types like numbers and strings when we know we need a particular type of variable. We’ll go over one of these later.

We then set up a variable to hold our parsed date string. We declare that variable by putting the var keyword in front of it. Javascript is pretty loose about declaring variables. The var keyword helps us define the scope of the variable. We’ll cover scope in a later tutorial, but scope helps us organize whether we can use a variable anywhere from a global scope or only within a function in a local scope. Just file that away so you can say, “ahh, yes. I remember something about that”, later.

After we have a container variable, we call our dateParseString function so we can place the value calculated in the function in our variable. Notice how the function is on the right side of the variable? In javascript, we evaluate the right side of the statement and place that in the left side of the statement, separated by the = in this case. So, in english, we call the parseDateFunction and place the return value of the function in our variable. Notice the return keyword in our function? It indicates that we will return that value back to the function callee which in this case is our dateStringParsed variable. We also set up our dateString variable that we will calculate at this point.

We now have the function skeleton setup. Let’s do the calculating. We’ll start with gathering some initial values from the variable jpgName

var jpgName = '0507230004461.jpg';
var dateStringParsed;
dateStringParsed = parseDateString(jpgName);
function parseDateString(jpgName){
     var evaluatedDateString = '';
     var year =jpgName.substring(0,2);
     var month = jpgName.substring(2,4);
     var day = jpgName.substring(4,6);
     var hour = jpgName.substring(6,8);
     var minutes =jpgName.substring(8,10);
     var seconds = jpgName.substring(10,12);            

}

Dan told us that the jpg name followed a very specific pattern. He said: Each still is named with the date and time it was taken. For example 0507270505011.jpg would have been taken yy/mm/dd/hh/mm/ss/(camera ID). This is the kind of task a script is really great with. We figure that every 2 characters based on location in the name will represent a certain value. We can than assign values to our variables based on this knowledge. . How do we get those values? We use a built in function that javascript assigns to every string. We are going to use the substring function. The substring function allows us to call that function from a string variable and return a string that starts at the first location called and ends at the last.var year = jpgName.substring(0,2); would then return ‘05′. Notice how the first called value is 0? A lot of beginners get tripped up with using 0 as the first value of a container. In general, javascript containers begin with 0 as the first value, so it is important to get your head around that. Programming is a lot like math, but if you remember a bit of algebra it can seem like what you remember as functions, etc. don’t work like you remember them. As you get familiar with programming it will seem less strange.

Let’s move on. We’ve assigned variables from our parsed jpeg and now we need to format them into a useful date. Here is the next part of our function:

var jpgName = '0507230004461.jpg';
var dateStringParsed;
dateStringParsed = parseDateString(jpgName);
alert(dateStringParsed);

function parseDateString(jpgName){
	var evaluatedDateString = '';
	var year =jpgName.substring(0,2);
	var month = jpgName.substring(2,4);
	var day = jpgName.substring(4,6);
	var hour = jpgName.substring(6,8);
	var minutes =jpgName.substring(8,10);
	var seconds = jpgName.substring(10,12);     

   switch (month)
   {
      case "01":
         month = 'January';
         break;
      case "02":
         month = 'February';
         break;
      case "03":
         month = 'March';
         break;
      case "04":
         month = 'April';
         break;
      case "05":
         month = 'May';
         break;
      case "06":
         month = 'June';
         break;
      case "07":
         month = 'July';
         break;
      case "08":
         month = 'August';
         break;
      case "09":
         month = 'September';
         break;
      case "10":
         month = 'October';
         break;
      case "11":
         month = 'November';
         break;
      case "12":
         month = 'December';
         break;

   }
 }

Here we use a switch statement to convert our numeric month to a month string. A switch statement is another version of an if..else conditional statement. if..else allows us to test for a condition and either match a checked value or continue on to the next statement. In some cases, a switch statment is easier to read. In checking for a month, the switch statement allows us to stack the month variables one on top of each other and at first glance you can tell what we're trying to do.

In programming, it is almost as important to be able to read the program easily as it is for the function to work correctly. This is so when another programmer reads your program it is clear what you were trying to accomplish. Even if you don't work with other programmers, if you try to read your own code a few months from now you'll wonder what the guy or gal who wrote this code was thinking about. It's a weird thing the first time you read your own code and wonder who wrote this ****. Another important component of understanding code is to use comments. Comments allow you to set up the scenario for your code. We'll go over comments in a future article.

There is one tricky part in our switch statement. Notice how we check for '01', '02'? If we test for 1, 2, etc. the test will fail. Why is that? Remember how we talked about types earlier. This is a case where we are checking for a string value and not an integer. Most of the time that flexibility is useful, but if you find yourself not getting the values you expected, one of the first things to check is some kind of type mismatch.

The next part of our function converts our two digit date into a full date string. Remember the Y2K bug? We recreate it right here in our function. In our case we'll assume the date is post 2000, but that is a big assumption in large bulky systems. Luckily for us, this isn't a large bulky system. Btw, the //assume 2000+ for year is an example of a comment, nice of us to tell them we are going to break their system isn't it?

//assume 2000+ for year
year = "20" + year;

The last part of our function is a really great example of using conditionals. We check and format our minutes variable. We also check and format to AM or PM based on what we know about the date. This is also a very simple example of an algorithm. If we were going to be fancy, it's also a heuristic algorithm, because we take what we know about the problem and work out a system that returns the correct value without relying on a mathematical proof to generate that value. In scripting, we do this a lot. We find a way to get the values we are interested in without concerning our self too much about the theory behind it. Of course that opens ourself up into outlying cases that can produce bugs and it certainly is better to understand the whole problem if it is of a complex nature. In this case we'll just get our work done.

The minutes and AM/PM logic:

if(minutes > 0){
      minuteFormat = ":" + minutes;
   }else{
      minuteFormat = ":00";
   }   

   if(hour == 0){
      timeFormat = "12" + minuteFormat + " AM";
   }else if(hour < 12){

      timeFormat = hour + minuteFormat + " AM";

   }else if(hour > 12 && hour != 24){
      hour = hour - 12;

      timeFormat = hour + minuteFormat + " PM";
   }else if(hour == 12){
      timeFormat = hour + minuteFormat + " PM";
   }else if(hour == 24){
      timeFormat = "12" + minuteFormat + " AM";
   }

Notice these two conditional checks, if(minutes > 0){ and if(hour == 0){. These are examples of where javascript is doing it's own type coercion. Type coercion is when the interpreter makes an assumption about the types necessary to perform a task. Since we are checking for greater than value for example, it makes the assumption that we want to compare the string as an integer. Most of the time this works, but if we wanted to explicitly change the value to a number, we could use a built in javascript function called parseInt() to give the interpreter the information that this was definitely an integer
This is also where things sort of look like the math you remember, "hey, I know > means "greater than", but what's with the != and ==?". When we do a comparison using if..else we use comparison operators to do that comparison. The == characters indicate we are asking does the value of the left side equal the value of the right side. If we used != we are asking the interpreter does the value on the left not equal the value on the right.
When we use && above, we are using a logical operator. When we write, else if(hour > 12 && hour != 24){ we are asking the interpreter to evaluate whether hour is greater than 12 AND hour is not equal to 24. The && is a logical operator that means AND. Javascript also has the || OR logical operator and the ! NOT logical operator.
If I run our final function from within a browser, Flash (change the alert(dateStringParsed);to trace(dateStringParsed);), or the scripts menu in After Effects:

var jpgName = '0507230004461.jpg';
var dateStringParsed;
dateStringParsed = parseDateString(jpgName);
alert(dateStringParsed);

function parseDateString(jpgName){
	var evaluatedDateString = '';
	var year =jpgName.substring(0,2);
	var month = jpgName.substring(2,4);
	var day = jpgName.substring(4,6);
	var hour = jpgName.substring(6,8);
	var minutes =jpgName.substring(8,10);
	var seconds = jpgName.substring(10,12);     

   switch (month)
   {
      case "01":
         month = 'January';
         break;
      case "02":
         month = 'February';
         break;
      case "03":
         month = 'March';
         break;
      case "04":
         month = 'April';
         break;
      case "05":
         month = 'May';
         break;
      case "06":
         month = 'June';
         break;
      case "07":
         month = 'July';
         break;
      case "08":
         month = 'August';
         break;
      case "09":
         month = 'September';
         break;
      case "10":
         month = 'October';
         break;
      case "11":
         month = 'November';
         break;
      case "12":
         month = 'December';
         break;

   }

   //assume 2000+ for year

   year = "20" + year;

   if(minutes > 0){
      minuteFormat = ":" + minutes;
   }else{
      minuteFormat = ":00";
   }   

   if(hour == 0){
      timeFormat = "12" + minuteFormat + " AM";
   }else if(hour < 12){

      timeFormat = hour + minuteFormat + " AM";

   }else if(hour > 12 && hour != 24){
      hour = hour - 12;

      timeFormat = hour + minuteFormat + " PM";
   }else if(hour == 12){
      timeFormat = hour + minuteFormat + " PM";
   }else if(hour == 24){
      timeFormat = "12" + minuteFormat + " AM";
   }

   evaluatedDateString = month + " " + day + ", " + year + "  - " + timeFormat;

   return evaluatedDateString;
} 

I get July 23, 2005 - 12:04 AM, which seems to pass the test of what we are trying to get our script to do.If this is an actual production script I would encourage you to try a bunch of different values and also to check and return for invalid values so that you don't break other parts of your system. I've got tutorials on user and unit testing as well as debugging coming up.

Don't be intimidated by scripting. Dive right in. The worst thing that can happen is you might be confused for a bit, but by being diligent and doing some tutorials you'll get useful stuff happening before too long. I especially wouldn't worry too much about the more heavy computer science ideas. While I don't question the importance of the theory behind the math and programming you might use, it tends to make us feel like we have to ask permission to try things out and that's simply not true.

Around the middle of last year a security exploit was found in the implementation of the XML-RPC protocol in PHP. PHP is obviously a very popular web scripting language and dozens of content management systems, including the blogging software I use for this blog, utilize the language. Now an open security hole in such a popular language is just an invitation for the underground to attempt to exploit the situation, and try to exploit they did.

It started out as just a trickle, but before long it became obvious that the underground was attempting to exploit the security hole. How’d we know? By analyzing our logs.

An access log is generated by your web server, in our case Apache, and contains a lot of information. For example, here is a random line from this blog.

208.52.128.170 - - [28/Apr/2006:11:07:53 -0700] "GET /wp-content/themes/rdc/style.css HTTP/1.1" 200 7581 "http://www.creative-workflow-hacks.com/" "Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en-us) AppleWebKit/418 (KHTML, like Gecko) Safari/417.9.2"

The first column is where the ip request comes from. The second is the date. The third is the url and the GET means it uses a GET style HTTP request. The fourth is the user agent, in this case Safari. So that’s all well and good, but what’s that have to do with the security exploit?

Well, by looking at your raw access logs, you start to notice patterns. Something like this is what we started to see in our access logs.

209.213.106.25 - - [26/Apr/2006:05:46:19 -0400] "GET /xmlrpc.php HTTP/1.0" 404 1453

and

209.213.106.25 - - [26/Apr/2006:05:46:20 -0400] "GET /drupal/xmlrpc.php HTTP/1.0" 404 1453

Drupal? We're not using Drupal. What was happening were attempts to exploit the security hole. And there were quite a few attempts and they kept coming.

So was this some lone hacker typing into her browser? Not likely. What was happening was bots.

You've probably heard about spyware. In addition to sending you all kinds of weird popups and putting casino shortcuts on your desktop, malware like this can take over your computer and do things like send spam email, or in this case attempt to send security exploits to take over yet more computers and send spam email and then attempt...well, you get the picture.

So by analyzing our logs we start to get a picture of what to watch out for and figure out what software *really* needs to be up to date. Better get over to wordpress and check for patches

What I want to show today is one little tool that I used to analyze our logs while this exploit was going on full tilt, although we still see a lot of requests for xmlrpc as the last laggards still haven't updated their software and the law of diminishing returns kicks in for the bots

We're going to use the command line today (it's really not that scary, you might even end up with 10 different shells open on your deskop one day like a real unix grey beard...don't laugh, it could happen).It goes without saying that the following will only work if your webserver is running apache and you have unix shell acess to the server your log files are kept. The first order of business is to find out where your log files are kept. A common location is /var/log/httpd or if your on a shared host, a logs directory in your home directory. Once you've figured out where your log file is located, let's cd to that directory.

Unix tools are designed to do one thing very well and work in conjunction with other small tools that do one thing well to accomplish the task at hand. Unix tools have a concept called standard input and standard ouput which allow each tool to do their bit of business and then pass the result on to the next tool. The command we are going to use today is:

cat access.log | grep xmlrpc |  awk '{print $1}' | sort | uniq | wc -l

Scary huh? But don't freak out. We'll go through each part and you'll start to understand that it really is easy and you might be able to do some useful work with this command line stuff any how.

So let's start off with the first part. Commands start from the left like you're reading a sentence. cat access_log catalogs or writes out the acess_log to standard output which in this case is the terminal in which you typed the command. Your version of your access_log might be named something else like access.log or somesuch, but you should be able to figure it out. You could also use tail command if you had an access_log that is several days long and you only want to check out just the last bit of access.

Use tail -n 100 to grab the last 100 entries. Which brings us to Unix command switches, the -n 100 is a command switch. Most unix commands let you alter the base behavior of the command with a switch. How do you know which switches to use? You use the man command. Type man tail and see what you get.

A lot of the stuff in a man can seem hopelessly geeky at first, but with a little perserverance we can find what we need. So we've written out our access_log file. This is the raw data that comes from the web server. Take a look around, it's pretty interesting even before you've run analytics on it, but for most folks it's just too overwhelming to find anything useful. Let's take a look at the next part of our command.

cat access_log | grep xmlrpc

the | is the pipe indicator. We talked earlier about standard input and standard output. The | lets us pipe the output of cat into the input of grep. If we wanted to write out our acess_log to a file we would use the > character.

tail -n 100 access_log > ourfile.txt

would write a file called ourfile.txt with the last 100 lines of our access_log.

Back to our command. We pipe the output of our access_log to something called grep. What is grep? Grep stands for "generalized regular expression processor". Grep allows us to search for patterns in our output called regular expressions. Think of a regular expression as a find and replace on steroids. Regular expressions can get really complicated, but in our command we're just looking for xmlrpc. It won't match on variations with upper case or with dashes, etc., but it's surprisingly effective here.

Let's move on to

cat access_log | grep xmlrpc | awk '{print $1}'

We now pipe any matches on xmlrpc to awk. awk is a general purpose language that is designed to process text data. I don't use awk a lot, but it is really handy to grab a specific column from text output. That's what we do here. awk'{print $1}' takes only the first column and prints that to standard output. So from the first three parts of our command, we've printed the ip address of every access on our web server that used the word xmlrpc. Pretty neat. Let's move on.

cat access_log | grep xmlrpc | awk '{print $1}' | sort

All of those ip addresses are all over the place. Let's sort them into something useful. We first sort them numerically with sort.We use the uniq command to grab only the unique ip's. These bots might hit us once or a bunch of times, but we are only interested in grabbing the unique ones.

cat access_log | grep xmlrpc | awk '{print $1}' | sort | uniq

If we stop here we get a sorted, unique ip list of requests for xmlrpc. If we had a blackhole list we could add these ip's and not accept requests from these ip's in the future when the next exploit becomes available. We do need to be careful with that though because your most important customers might have a virus or spyware and not be able to access your site or your grep search string might find ip's that are accessing your site legitimately, use your judgement.

And finally

cat access_log | grep xmlrpc | awk '{print $1}' | uniq | sort | wc -l

let's use the word count command wc command with the -l switch to count the number of lines. 137. Wow. During the worst of our xmlrpc weirdness we were getting 137 unique ip's trying to exploit our web server.Definitely time to check for patches.

So that's it. This was definitely a long-winded post, but I hope you find it useful especially if your new to the command line. Like most things computer oriented, try to break down your big goal into smaller pieces until you work out the combinations that get you were you need to go.

THE SCENARIO

My boss approached me about a weird slowdown he was having where his machine was slowing to a crawl. Trying to move the cursor was taking a lifetime to move a couple of inches. There wasn’t a beachball cursor indicating an application was sucking up resources and I was able to launch programs, just very S L O W L Y.

So, what did we do?

I’ve done this stuff for a while and you start to get a sense of what seems like the usual suspects when you’re debugging an OSX problem. I’m going to run through the process I use and tell you about what we found out.

THE PROCESS

Step One.

We back up a lot of data at Primal Screen. We do both SD and HD video and have about 10 Terabytes of online storage and 5 Terabytes for near-line archive storage, combine that with individual client machine backups, and we, unfortunately, end up backing up during business hours. So when I hear about a mid-day slowdown, the first thing my “spidey-sense” goes off about is back-up. We use Retrospect from a central server so I did a quick check to see if it was running the client backup on Doug’s machine. Nope.

On to step two.

I also knew that Doug had recently installed Tiger(OSX 10.4) on his laptop. We are relatively late adopters on software for production machines and we’ve had enough problems with Tiger that it still isn’t universally adopted. One of the “features” we struggle with is Spotlight. Spotlight is a great idea. It indexes your data and allows for quick context sensitive searches, but it’s definitely a version 1.0 technology. The interface is a bit wonky and you can sometimes run into the next problem I suspected, Spotlight indexing. Spotlight needs to “index” your computer to gather all of the information that it uses. Indexing means that spotlight goes through the folders on drives that are searched by Spotlight and gathers the metadata from your files so that you can search it. While this is happening your machine can slow down and become unresponsive. So that’s the next place we look.

If you open Applications/Utilities/Activity Monitor (or for the geeky who like the command line, via Applications/Utilities/terminal top -o cpu), the process mds is active when Spotlight is either indexing or searching. The mdimport process is also active during indexing. If we were having Spotlight problems, those processes would be active and using excess CPU cycles. Nope, in this case.

If this turns out to be your problem, a great resource is available at thexlab.com on various ways of stopping and altering Spotlight indexing.

This is also the step where we would look for other programs taking too many CPU cycles. Sometimes you’ll have a spinning beachball cursor and not be sure of the source. Here’s where you’d check that.

On to step three.

THE SOLUTION

We now take a stop at Applications/Utilities/Console. The console is where applications send data about their current state. You’ll find errors, status and crash information here. The GUI hides a lot of interesting information from you. Some of it is a bit geeky and extraneous but you can pick up a lot of info and understanding about your computer by checking out the console.

So, we open it and I notice these entries….

SoundGrinderCMPlugInFactory-I-Debug
AllocCMPlugInType-I-Debug
SoundGrinderCMPlugInQueryInterface-I-Debug
SoundGrinderCMPlugInAddRef-I-Debug
SoundGrinderCMPlugInRelease-I-Debug
SoundGrinderCMPlugInExamineContext-I-Debug
SoundGrinderCMPlugInPostMenuCleanup-I-Debug

This looks promising…

hmmm, a CMPlugin is throwing debug info. A CM Plugin is a Contextual Menu plugin. Contextual Menus appear when you Control-click or Right-click (yeah, even macs work with two button mice these days) in a “context” that allows their use. Ok, but what is Sound Grinder?

Ahh, yes. Sound Grinder is an audio conversion utility we were checking out to convert some audio clips. Doug had removed the program when he decided to use a different app. But why was I still getting debug info? Sure enough, in /Library/Contextual Menu Items/ a SoundGrinderCMPlugIn.plugin file.

So, we’re definitely suspicious of this file. Let’s remove it. Another quick search for “uninstalling Sound Grinder” revealed:

To uninstall Sound Grinder you can simply drag the Sound Grinder folder to
the trash, and trash the plugin located at: /Library/Contextual Menu Items/SoundGrinderCMPlugIn.plugin. If you
wish to delete the preferences, look in the preference folder for a file
called "com.monkeytools.soundgrinder.plist", and drag to the trash.

We removed the plugin and that cleared up the problem. BTW, Sound Grinder seems like a very nice program and I’m not sure exactly why I was having the slowdown problems that we found related to the CMPlugin, although it probably didn’t help that we had yanked most of the rest of the program from the expected location.

I do think a nice universal OSX uninstall utility for programs that install things outside of the application bundle would be a good thing. I’ve got bits and pieces of no longer used detritus all over the place.

REFERENCE

So, in this case we caught our problem in the triage stage. Sometimes, you don’t find your problem here though. Where to next? I’ve had great success with Jaguar, Panther and Tiger Cache Cleaner from Northern Softworks. It runs a bunch of standard maintenance and utility scripts that tend to ferret out corrupt caches and permissions problems. For disk problems, I recommend DiskWarrior and avoid Norton (mainly for it’s insistence in leaving bits and pieces of itself everywhere, go figure). I’ve also been greatly assisted by John Gruber and his Daring Fireball site. His rundown of the Software Update process is a great piece of info and his font cache problem exposé is at least vaguely the inspiration for this post.

Hope you’ve find this helpful, and here’s hoping your avoiding these gotcha problems in your workflow.