Here are the criteria I used to narrow down the possible project management and time tracking solutions:

• Web based application
  Our devs use various platforms and it needs to run everywhere without install and upgrade headaches, I also considered Air and Flash apps
• Support for 5 users
  Because, yanno, we need five people to record time
• Time tracking must include timer with start/stop capabilities
  We are multi taskers and like accuracy; we considered products with timer widgets as well
• Feature list and pricing prominent
  Excluded all sites with vague details, no screenshots,  or “contact us for details and pricing” models, due to sheer volume and time needed to research
• Must have a free trial evaluation
  Yanno, so I could evaluate them
• Professional and sharp web site
  Attention to detail is critical to good software design and project management, how they run their site should reflect this

After nearly ten hours of research, I narrowed the field to fifteen products. Then I evaluated each product by importing several of our current projects into it and using the time tracking tools for one day. After which I ran reports and recorded my findings in a spreadsheet. The final ratings were on a 1-5 scale, based on usability, project management capabilities, time tracking capabilities, invoicing features, reporting capabilities, and API and integration tools. Here’s what I came up with:

Once I had some numbers to work with, I weighted each product to meet our needs, based on the following criteria:

• Usability: Ease and speed of use is very important to us, as we have little time for project management (x2)
• Time tracking capabilities: highly critical (x5)
• Project management capabilities: highly critical (x5)
• Low price:  we want to keep the price under $50 a month, so our value calculation was tweaked accordingly:  rating *3 – (price per month/10)
• Invoicing, reports, and so on are nice, of course, but we can make due with our external, existing solutions

So, using this data, here were my findings:

It should be apparent that ProWorkflow is, hands down, the best overall product on the market. It’s quality, well thought out, bug free, fast, and powerful. Skylight was by far the best for our needs, according to price versus quality. The rest of the data is interesting, but several of the products listed had a time tracking or project management rating less than three, which is insufficient for our needs. So the final choices for us were as follows:

• Skylight – use this and put up with the slow, laborious interface; our preference for now
• Basecamp + MyHours/Harvest/Tick – together, these products are a complete package, but pricey
• ProWorkflow – very pricey, but we could bite the bullet on this and get the best quality product on the market.

If you’d like to view or download the complete data, including links to all of the product sites, you can find all the gory details in the Google spreadsheet. You can also view the same data sorted by total quality instead.

Of course, if you use a lib like extjs, jQuery, et al, then you have no need of this. But if you’re trying to hack out a greasemonkey script or insert some minimalist code, here it is.

And here it is, for my own archives:

function getElementsByClass(searchClass,node,tag) {
	var classElements = new Array();
	if ( node == null )
		node = document;
	if ( tag == null )
		tag = '*';
	var els = node.getElementsByTagName(tag);
	var elsLen = els.length;
	var pattern = new RegExp("(^|\\s)"+searchClass+"(\\s|$)");
	for (i = 0, j = 0; i < elsLen; i++) {
		if ( pattern.test(els[i].className) ) {
			classElements[j] = els[i];
			j++;
		}
	}
	return classElements;
}

Here’s another alternative I found on Glazblog, using xpath to search the document:

document.getElementByClassName = function(needle) {
  var xpathResult = document.evaluate('//*[@class = needle]', document, null, 0, null);
  var outArray = new Array();
  while ((outArray[outArray.length] = xpathResult.iterateNext())) {
  }
  return outArray;
}

I don’t really know which is more efficient, though I suspect the xpath search could be taxing in very large documents. I’m positive, based on IE’s fake implementation of key/value pairs in the DOM, that they both suck in IE, even if you specify a specific tag type to search. Obviously, providing a node makes the regular expression search faster, by virtue of having less content to parse.

After about an hour of searching, I discovered that port 80 was in use by Skype. No kidding. There is an advanced setting in skype to “Use port 80 and 443 as alternate incoming connections.” If this is checked (which it is by default) then a service is started on port 80 that blocks Apache. Ungh for bad ideas and even worse defaults.

Here is a quick script for sending an email:

#!/bin/bash
 
# Subject of email
SUBJECT="Test email with attachment from a bash script"
 
# Where to send it
TO_ADDRESS="your@email.com"
 
# Where the attachment is
ATTACHMENT_FILE="/tmp/attachment.txt"
 
# For fun, let's put something into the attachment
echo "This goes into the file."  >  $ATTACHMENT_FILE
echo "This appends to the file." >> $ATTACHMENT_FILE
 
# send the message
/bin/mail -s "$SUBJECT" "$TO_ADDRESS" < $ATTACHMENT_FILE

http://colorschemedesigner.com/

sc delete ServiceName

You can find the service name by going to Control Panel -> Administrative Tools -> Services, right click the service and choose properties, the service name is shown there.

A few years ago I pulled a late-night session trying to debug a server at PacBell. The code looked fine, but every night the server would reboot and it was my job to figure out why. As I’m sitting there, testing the server at 1AM, in walks the janitor, UNPLUGS THE SERVER to plug in the vacuum, vacuums the room, then plugs the server back in. Case closed, I went home.

So here is what I came up with; a method that finds the next or previous word given a starting position in the string:

   /**
    * Abstracted method for finding the next/prev word. This method assumes that 
    * $pos is greater than zero and less than the length of $text (check before calling)
    *
    * @param string $text the string of text to find next/prev word in
    * @param int $pos the position of first character in current word
    * @param string $wordPattern the regex definition of a word without any matching parens
    * @param string $reverse looks backward instead of forward (finds last word in string)
    * @return mixed false if no more words or array( "the word matched with junk", "the word only")
    */
   private static function nextWordMatch($text, $pos, $wordPattern, $reverse = false) {
      // we get the substring of text, starting at the current position
      if( $reverse ) {
         // in this case, we look at everything before $pos; we reverse it so that
         // we can run a simple regex on it rather than trying to deal with craziness
         // of looking backwards in string
         $text = substr($text, 0, $pos-1);
      }
      else {
         // in this case, we look at everything after $pos
         $text = substr($text, $pos);
      }
 
      // we escape the preg character just in case
      // we add in two sets of match parens, one for the word and one for the whole match
      // when looking backwards, we need to look from the end rather than the start
      $wordPattern = str_replace('@', '\\@', $wordPattern);
      $pattern = "(({$wordPattern})".self::NON_WORD_CHARS.")";
      if( $reverse ) { $pattern = "@{$pattern}\$@"; }
      else { $pattern = "@^{$pattern}@"; }
 
      // perform the match now and figure out what to do with it
      preg_match($pattern, $text, $matches);
      if( count($matches) < 3 ) { // remember that the first match is the raw text, so we add one
         // we didn't find any words, so return false
         return false;
      }
 
      // strip off the raw text, leaving our two matches
      return array_slice($matches, 1);
   }

Here is the default value for $wordPattern and the constant NON_WORD_CHARS used in the example:

   private $wordPattern = '\b[\w]+(?:[-\']\w+)*\b';
   const NON_WORD_CHARS = '\W*';