Object-oriented folk may want to enclose these functions within an extended array object (or extend the Array object, if that’s your style):

var getArrayIndex = function(array, item){
    for (var i = 0; i < array.length; i++) {
        if (array[i] === item) {
            return i;
        }
    }
    return -1;
};
 
var deleteArrayItem = function(array, item){
    var index = getArrayIndex(array, item);
    if (index > -1) {        
        return array.splice(index, 1);
    }
    return array;
}

Using Array.indexOf might seem logical, but it’s mildly cross-browser problematic at the moment. Rather than using the common Array.indexOf workaround, I’m using a custom function because it’s less code and can be tweaked to suit any unique needs I might have.

var typefacehover = function (){                            
  $(".typeface-js").each(function(){
    //Get all the classes for an element. 
    var elementStyles = $(this).attr('class');
    elementStyles = elementStyles.split(' ');
    //Run through them and check for a :hover color property.
    var hoverColor;                                
    for (var i in elementStyles){                                        
      var temp = getCSSColor('.'+elementStyles[i]+':hover');                           
      if(temp) {
        hoverColor = temp;                                        
      }
    }
    if(hoverColor){
      var element = $(this).html();
      //Duplicate the element, create a new hover version of the element (hidden) and add a container to each one so that we can distinguish between the two.
      var hoverElement = '<div class="typeface-js-hover" style="color:'+hoverColor+';display:none">'+element+'</div>';
      element = '<div class="typeface-js-nohover">'+element+'</div>';
      var newElement = element + hoverElement;
      $(this).html(newElement);
 
      //Add the event listener. You could do fade transitions here if you wanted to be fancy.
      $(this).hover(
        function(){
          $(".typeface-js-nohover",this).hide();
          $(".typeface-js-hover",this).show();
        },
        function(){
          $(".typeface-js-nohover",this).show();
          $(".typeface-js-hover",this).hide();
        });
    }
  });
}
 
 
//Kudos: http://www.mail-archive.com/jquery-dev@googlegroups.com/msg03390.html
var getCSSColor = function(selector){                            
  var re = new RegExp('(^|,)\\s*'+selector.toLowerCase()+'\\s*(,|$)');
  var color;                            
  $.each ($.makeArray(document.styleSheets), function(){
    $.each (this.cssRules || this.rules, function(){    
      if (re.test(this.selectorText)) {                                        
        color = this.style.color;                                        
      }
    });
  });
  return color;
}

I hope to find the time to develop a more robust solution in the future. Let me know if this was helpful!

Months ago, in my mission to find a good solution for using fancy fonts on the web, I had a choice between sIFR and typeface.js. sIFR uses Flash to render text, and typeface uses the <canvas> element (or VML in IE). Other than the difference in implementation, however, their feature-set looked about the same, at least for my simple purposes: they were both javascript driven, both allowed text to be selected, and they both looked damn good.

But typeface.js had one crippling debilitation. It didn’t have :hover support. Weak. So I went with sIFR.

First, I found sIFR’s configuration to be a pain. Well, that’s OK. I only have to learn the setup once, then I can copy+paste my code.

Then I found that it had z-index issues in IE, particularly when using them as links and tying the :hover directive together with an image change. Annoying, but it’s flash based and IE is always a pain. Fine.

Then I noticed that my jQuery animations (slide effects) were slowed down when sIFR elements were included in the animated element. Hmmm.

Then I started using a lot of sIFR elements on one page… significant loading delay. Hrmph.

Then it came to my attention that every once in a while the sIFR elements would fail to load altogether in IE on those sIFR-heavy pages. Uh…. sIFR, we’re through. This just isn’t going to work out. It’s not me, it’s you. It was great while it lasted (wait, no.. not really). Ciao.

And then I said hello to typeface.js. Configuration? Piece of cake. Speed? Fast! Reliability? Hasn’t failed me yet. Z-index issues? None. Lack of :hover support?

I can live with that.

It’s also worth noting that a HEAD request also returns the content length and last modified date, and that jQuery has an “ifModified” option for the .ajax function that returns a boolean value.

Quick code snippet:

$.ajax({
    url:'http://www.example.com/somefile.ext',
    type:'HEAD',
    error:
        function(){
            //do something depressing
        },
    success:
        function(){
            //do something cheerful :)
        }
});

Couldn’t be easier!

The solution is to pass your variables on in an array. Here’s the template that I use whenever I code a new function:

function example($args="") {
    $variable1 = $args['variable1']? $args['variable1'] : 'default';
}

And this is how you pass variables on to your function:

$args = array(
    'variable1' => 'value',
    'variable2' => 2,
    'variable3' => $etc
);
example($args);

And what’s more, if you have an existing function that you want to convert to taking an array, but don’t want to change all of your existing function calls, you can do something like this:

function example($args="", $variable2, $variable3) {
    if (is_array($args)) {
        $variable1 = $args['variable1']? $args['variable1'] : 'default';
        $variable2 = $args['variable2']? $args['variable2'] : 'default';
    } else{
        $variable1 = $args;
    }
}

Clean, tidy, and easy as pie.

Step 1: You need to edit your .htaccess file to incorporate some mod rewrite rules. This is the code that we’re going to use (the same code that WordPress uses):

RewriteEngine On
RewriteBase /
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /yourcode.php [L]

What this does is capture the “filenames” (really just a URI string that comes after your site root), and pass them on in an array to the file of your choice, “yourcode.php” in this case. It does all this without changing the URL on the user’s end. So now all we have to do is pick up those variables in our PHP code. We’ll do that with this code in yourcode.php :

$uri = $_SERVER['REQUEST_URI'];
$vars = explode('/', $uri);

So now we’ve captured the elements of the permalink in our array $vars, starting with the second array object, $vars[1]. The first array object, $vars[0] will return as blank. So let’s suppose the user is trying to go to this address:

http://www.yoursite.com/someuser/profile

$vars[1] will be “someuser”. $vars[2] will be “profile”. We can then use that information like so:

$user = $vars[1];
$page = $vars[2];

… and then use those variables to determine what data we output to the browser.

Easy as pie.

Mine’s a little different. It’s a place for me to post my own music. Mostly just rough recordings of song ideas—I think of them as song seeds, since they’re very short and I can flesh them out into more polished material at a later date (and hopefully in the future I’ll be posting that polished material as well).

The seed was planted one day earlier, on the 28th. I was talking with my friend Leah about a story she had written. It was short and simple, but it was built around a very unique and clever concept.

“How did you come up with that idea?” I asked her.

She said, “Well I was talking to a friend and he said something, and I thought, ‘hmm, that could be a story!’” We continued to chat and I didn’t think too much about those words at the time.

A day went by.

On the 29th, I was doing the dishes, and my brain was doing what it usually does when it’s on idle. It was replaying recent conversations. As I replayed that small snippet of my conversation with Leah, an idea struck me: Maybe all I have to do is say those words… so as I was scrubbing away at a particularly tough stain, I gave it a whirl. “Hmm, that could be a story!” I said.

Nothing happened.

Well, it can’t be that easy, can it? I was still convinced that I was on to something, though—I’m all about self-conditioning behavior by establishing and practicing routines—so I decided to get into the habit of reciting those words on a frequent basis. I said them in my head every chance I could.

Sure enough, later on that day, as my brain was once again recounting a conversation I’d had (this one was a little stale, being over a week old, but still tasty), I said those words to myself at just the right moment… and a story flooded into my head. It was like flipping on a light switch. One moment there was nothing. The next moment, I could see the whole thing. It worked! I was psyched.

Later on that day, as I was reading the news, I had another “hmm, that could be a story” moment… and then another an hour later. By the end of the day, I had a total of four story ideas, and each one of them struck me as genuinely interesting. To put this into context, that’s more story ideas than I had developed in the past year, much to my frustration.

It’s only been two weeks since then, but I’ve already had over twenty story ideas. At least one a day, as frequently as four times a day. Every one of them captivates me somehow. Most of them resonate with me in a very personal way.

While I don’t have the time to develop all of these ideas, that’s the least of my concerns. I’m one giant step ahead of where I was a few weeks ago. In terms of creative ideas, my mind went from being a barren wasteland to a healthy, slightly overgrown garden. Not too shabby.

But why did four and a half words make such a big difference for me? Here’s what I think happened: Those ideas were already there. But interesting ideas don’t lounge about waiting for you to notice them. They’re fleeting little things that hide in the nooks and crannies of your mind when you set out to look for them.

Want them? Then you have to catch them in the act. Find your weapon (mine are four and a half words, yours may be different), have it on hand at all times, and be ready to use it every chance you get.

Oh, and write them down. Ideas are slippery little things.

Note: This article was written for Writing Experiment #3. Join us.

Which begs the question: Why do we value decisiveness so much? Wouldn’t it seem logical to conclude that the best decisions are made with patience and consideration?

Well, yes… theoretically. But there’s a fatal flaw in that logic: It fails to consider fundamental human nature. Our minds are brilliant strategists. They play tricks on us constantly. My brain has tricked me out of  exercise, work, and opportunity a thousand times over… and masking indecision as “careful forethought and consideration” is one of its best weapons.

It works like this: I have to do something that involves making a decision. My brain says, “Hmm, let’s think about that first. How about we contemplate it while making a nice cup of tea?” I think to myself, What a great idea, brain! So I make the tea, and as I’m doing so, my brain whips out another trick. This one’s called, “A Quick Bite to Eat,” and it gets me every time. I cook. I eat. I get a phone call or an email. I get sidetracked.

Next thing I know, it’s tomorrow afternoon. Same time. Same place. Same decision sitting in front of me. And this time, my brain’s tricks are even more effective, because they’ve been re-enforced by my behavior from the previous day. So in the long run, that single moment of indecision had a huge impact on me.

Conclusion: Individual moments of indecision aren’t inherently bad. But when they become part of a pattern of procrastination, then you have a problem.

And I have a solution. It’s simple, really. Any time your brain sees a fork in the road and doesn’t want to choose one path or the other, you need to help it along. You need to have a procedure for making that decision. Just a few small steps that you know can be accomplished easily enough, without hesitation.

Let’s use a simple example: You’re asked whether you want Chinese pizza or Italian sushi for dinner. They both sound delicious to you and you could go either way. You don’t know what to say. Maybe you want to shrug and say, “Whatever, whichever.” But instead, you know that any time you’re faced with a decision and all options are equally good, your procedure is to first ask yourself which one is healthier. If there’s a clear-cut answer, then you choose that one. If not, you choose the first option that was mentioned.

That’s a procedure. All you have to do to employ them yourself is keep your eye out for moments of indecision in your own life, and then build your own procedures to prevent them from happening. Problem solved. Productivity improved. End of story.

P.S. Your brain will attempt to trick you out of your procedure initially. Mine is very good about making me forget things it finds inconvenient. Just keep trying, don’t give up, and it will eventually give in.

This article was in response to AnotherGuy’s Writing Experiment #2.