Here are some important products that can be derived from processing petroleum OR algae:

• Gasoline (biogasoline)
• Diesel fuel (biodiesel)
• Jet fuel (aviation biofuel)
• Plastics (bioplastic)

And yes, the algae-based fuels (and plastics) work just as well as the petroleum-based fuels, and can be used in existing engines without any modification. Engines will run the same and burn cleaner (although they still emit CO2).

Of course algae and petroleum aren’t exactly the same. Petroleum can be processed to get: tar, asphalt, and pesticides. Algae can be processed to get: nutrients, animal feed, and vegetable oil.

Biofuels (like biodiesel) can be produced from any biomass (like corn, soy, or even wood chips). However, the efficiency (in terms of oil yield per acre) of algae is astronomical compared any other feedstock.

Graphic I stole from: http://www.energyandcapital.com/articles/biofuel-algae-biodiesel/395

Algae:

• naturally takes CO2 out of the atmosphere and releases oxygen (while alive)
• grows very fast (harvest cycle of 1–10 days)
• does not require fresh water (seawater and wastewater will do)
• does not require quality farm land (dry or saline soil will do)
• actually thrives off wastewater (found at a wastewater treatment facility, post-bacteria)
• also thrives by consuming CO2 emissions directly from factories and power plants

Algae farms can easily have symbiotic (mutually beneficial) relationship with cement factories, coal power plants, wastewater treatment facilities, or any other facility that produces CO2 emissions. For example, CO2 emissions are normally an unwanted bi-product. However, pumping the CO2 through algae will reduce the emissions and feed the algae growth leading to faster oil production.

Properly produced biofuels can be used in existing engines without modification. You’d have to modify a diesel engine to run on vegetable oil, yes, but it can be done. However, biodiesel is essentially the same as “petrodiesel” and can be used as a drop in replacement. To quote an article:

These biofuels, which some refer to as “renewable petroleum,” will be designed with the same properties of hydrocarbons that now fuel our vehicles, but be made from biomass, rather than petroleum.

Custom-designed synthetic fuels are very appealing to established fossil fuel providers because, unlike ethanol, they should not require significant changes to the existing fuel infrastructure, said Nathanael Greene, a biofuels policy analyst at the National Resource Defense Council (NRDC).

http://news.cnet.com/8301-11128_3-9849832-54.html

Plastic can also be derived from algae (as opposed to petroleum). See:
http://www.celsias.com/article/cereplast-algae-plastic/
http://en.wikipedia.org/wiki/Bioplastic

Videos

A couple of algae based companies have decent YouTube videos promoting their work.

PetroAlgae

Valcent / Vertigro

Investing

I wish I could just invest in an index of all companies doing work with algae. However, no such index exists. Additionally, many companies doing good work are still privately owned. They are competing and guarding their secrets; thus slowing down progress. However, in the end, we will all benefit from the good ol’ American competition.

During my research, these companies stuck out:

• PetroAlgae (PINK: PALG)
• OriginOil (OTC:OOIL)
• Valcent / Vertigro (public, but confusing digital presence)
• PetroSun (PINK:PSUD)
• Cereplast (NASDAQ:CERP)
• Solazyme (IPO coming soon!)
• Sapphire Energy
• BioEcoTek

Many sites discussing the up-coming algae market and companies refer to this list of 15 promising startups

For more on investing in green companies (including algae biofuels), check out:
http://www.greenchipstocks.com/
http://greenworldinvestor.com/

For general news and information on the algae industry, check out:
http://www.oilgae.com/
http://www.algalbiomass.org/
http://www.algaeindustrymagazine.com/

More Wikipedia pages:
List of algal fuel producers
List of biofuel companies and researchers

Cost and Timeline

Currently it’s cheaper to drill for petroleum. However, petroleum is a limited resource and prices are always going up. Meanwhile, technology surrounding harvesting and processing algae for biofuels and other products keeps getting better and cheaper. It’s only a matter of time before those 2 lines cross on the graph.

Obama supports domestic biofuels. If the government started officially endorsing (probably via tax credits) biofuels, and stopped supporting “petrofuels”, I am confident that we would be able to make the switch from fossil fuels to renewable fuels (for the vast majority of its applications).

This market is just waiting to explode. In the future, vehicles may have engines that work in completely different ways. For example, the hydrogen fuel cell, which powers electric cars and only releases water as the bi-product. However, for the time being, we have to deal with the millions of vehicles and engines that already exist. The intermediate step will be to replace the FUEL.

The main problem is Windows. Many Windows programs use Windows-1252 character encoding, which is very similar to ISO-8859-1, but with some differences. Attempts to detect the encoding of a Windows-1252 string will tend to result in a guess of ISO-8859-1. So conversion tools will overlook the differences. Unfortunately, there are some relatively common characters among the differences. These characters include left/right angled single/double quotes, em/en dashes, ellipsis, and bullets.

To deal with these encoding issues, I wrote a function to do the cleanup and convert the string to UTF-8.

Note: I have only tested this with the English language / character set.

Full disclosure: PHP must have the mbstring extension enabled to use the mb_* functions.

<?php
/**
 * cleanEncoding deals with pesky characters like curly smart quotes and em dashes (and some other encoding related problems)
 *
 * @param string $text Text string to cleanup / convert
 * @param string $type 'standard' for standard characters, 'reference' for decimal numerical character reference
 *
 * @return $text Cleaned up UTF-8 string
 */
function cleanEncoding( $text, $type='standard' ){
    // determine the encoding before we touch it
    $encoding = mb_detect_encoding($text, 'UTF-8, ISO-8859-1');
    // The characters to output
    if ( $type=='standard' ){
        $outp_chr = array('...',          "'",            "'",            '"',            '"',            '•',            '-',            '-'); // run of the mill standard characters
    } elseif ( $type=='reference' ) {
        $outp_chr = array('&#8230;',      '&#8216;',      '&#8217;',      '&#8220;',      '&#8221;',      '&#8226;',      '&#8211;',      '&#8212;'); // decimal numerical character references
    }
    // The characters to replace (purposely indented for comparison)
        $utf8_chr = array("\xe2\x80\xa6", "\xe2\x80\x98", "\xe2\x80\x99", "\xe2\x80\x9c", "\xe2\x80\x9d", '\xe2\x80\xa2', "\xe2\x80\x93", "\xe2\x80\x94"); // UTF-8 hex characters
        $winc_chr = array(chr(133),       chr(145),       chr(146),       chr(147),       chr(148),       chr(149),       chr(150),       chr(151)); // ASCII characters (found in Windows-1252)
    // First, replace UTF-8 characters.
    $text = str_replace( $utf8_chr, $outp_chr, $text);
    // Next, replace Windows-1252 characters.
    $text = str_replace( $winc_chr, $outp_chr, $text);
    // even if the string seems to be UTF-8, we can't trust it, so convert it to UTF-8 anyway
    $text = mb_convert_encoding($text, 'UTF-8', $encoding);
    return $text;
}
 
?>

If you are interested in more information on this topic, here are some links you may find helpful:
http://www.joelonsoftware.com/articles/Unicode.html
http://shiflett.org/blog/2005/oct/convert-smart-quotes-with-php#comment-3
http://web.forret.com/tools/charmap.asp?show=ascii
http://en.wikipedia.org/wiki/Extended_ASCII
http://www.ascii-code.com/
http://stackoverflow.com/questions/631406/what-is-the-difference-between-em-dash-151-and-8212
http://en.wikipedia.org/wiki/Numeric_character_reference
http://www.dwheeler.com/essays/quotes-in-html.html
http://www.i18nguy.com/markup/ncrs.html
http://www.kadifeli.com/fedon/utf.htm

I yanked this function from a blog who looks like they yanked it from another blog, who yanked in from the CakePHP framework. This function is too good not to share.

<?php
/**
 * truncateHtml can truncate a string up to a number of characters while preserving whole words and HTML tags
 *
 * @param string $text String to truncate.
 * @param integer $length Length of returned string, including ellipsis.
 * @param string $ending Ending to be appended to the trimmed string.
 * @param boolean $exact If false, $text will not be cut mid-word
 * @param boolean $considerHtml If true, HTML tags would be handled correctly
 *
 * @return string Trimmed string.
 */
function truncateHtml($text, $length = 100, $ending = '...', $exact = false, $considerHtml = true) {
	if ($considerHtml) {
		// if the plain text is shorter than the maximum length, return the whole text
		if (strlen(preg_replace('/<.*?>/', '', $text)) <= $length) {
			return $text;
		}
		// splits all html-tags to scanable lines
		preg_match_all('/(<.+?>)?([^<>]*)/s', $text, $lines, PREG_SET_ORDER);
		$total_length = strlen($ending);
		$open_tags = array();
		$truncate = '';
		foreach ($lines as $line_matchings) {
			// if there is any html-tag in this line, handle it and add it (uncounted) to the output
			if (!empty($line_matchings[1])) {
				// if it's an "empty element" with or without xhtml-conform closing slash
				if (preg_match('/^<(\s*.+?\/\s*|\s*(img|br|input|hr|area|base|basefont|col|frame|isindex|link|meta|param)(\s.+?)?)>$/is', $line_matchings[1])) {
					// do nothing
				// if tag is a closing tag
				} else if (preg_match('/^<\s*\/([^\s]+?)\s*>$/s', $line_matchings[1], $tag_matchings)) {
					// delete tag from $open_tags list
					$pos = array_search($tag_matchings[1], $open_tags);
					if ($pos !== false) {
					unset($open_tags[$pos]);
					}
				// if tag is an opening tag
				} else if (preg_match('/^<\s*([^\s>!]+).*?>$/s', $line_matchings[1], $tag_matchings)) {
					// add tag to the beginning of $open_tags list
					array_unshift($open_tags, strtolower($tag_matchings[1]));
				}
				// add html-tag to $truncate'd text
				$truncate .= $line_matchings[1];
			}
			// calculate the length of the plain text part of the line; handle entities as one character
			$content_length = strlen(preg_replace('/&[0-9a-z]{2,8};|&#[0-9]{1,7};|[0-9a-f]{1,6};/i', ' ', $line_matchings[2]));
			if ($total_length+$content_length> $length) {
				// the number of characters which are left
				$left = $length - $total_length;
				$entities_length = 0;
				// search for html entities
				if (preg_match_all('/&[0-9a-z]{2,8};|&#[0-9]{1,7};|[0-9a-f]{1,6};/i', $line_matchings[2], $entities, PREG_OFFSET_CAPTURE)) {
					// calculate the real length of all entities in the legal range
					foreach ($entities[0] as $entity) {
						if ($entity[1]+1-$entities_length <= $left) {
							$left--;
							$entities_length += strlen($entity[0]);
						} else {
							// no more characters left
							break;
						}
					}
				}
				$truncate .= substr($line_matchings[2], 0, $left+$entities_length);
				// maximum lenght is reached, so get off the loop
				break;
			} else {
				$truncate .= $line_matchings[2];
				$total_length += $content_length;
			}
			// if the maximum length is reached, get off the loop
			if($total_length>= $length) {
				break;
			}
		}
	} else {
		if (strlen($text) <= $length) {
			return $text;
		} else {
			$truncate = substr($text, 0, $length - strlen($ending));
		}
	}
	// if the words shouldn't be cut in the middle...
	if (!$exact) {
		// ...search the last occurance of a space...
		$spacepos = strrpos($truncate, ' ');
		if (isset($spacepos)) {
			// ...and cut the text in this position
			$truncate = substr($truncate, 0, $spacepos);
		}
	}
	// add the defined ending to the text
	$truncate .= $ending;
	if($considerHtml) {
		// close all unclosed html-tags
		foreach ($open_tags as $tag) {
			$truncate .= '</' . $tag . '>';
		}
	}
	return $truncate;
}
 
?>

I’ve seen these many times over the years. Each time I was slightly curious, but never felt motivated to look it up – until today.

These formations are commonly referred to as “ice spikes”. They seem to grow most readily with distilled water and an air current. They can also form with regular tap water, although much less frequently. Every time I have personally witnessed these formations has been using regular tap water in regular ice cube trays.

The idea is that the edges, including the surface, freeze faster than the interior of the ice cube. Water expands as it freezes, so if the surface is (nearly) frozen over, pressure will build up from the interior of the cube, and water will force its way up. This can form a tunnel or tube that the water travels up until freezing along the rim of the tube (forming the ice spike).

Illustration I stole from CalTech

CalTech with some good info:
http://www.its.caltech.edu/~atomic/snowcrystals/icespikes/icespikes.htm

More links pertaining to ice spikes:
http://www.physics.utoronto.ca/~smorris/edl/icespikes/icespikes.html
http://en.wikipedia.org/wiki/Ice_spike
http://www.halbertcicles.com/how.htm
http://www.sciforums.com/Unexplainable-Water-Phenomenon-t-46063.html

We were creating DBM files (from text files) for use by Apache/mod_rewrite using the httxt2dbm utility. If you create “file.dbm” it actually creates “file.dbm.pag” and “file.dbm.dir”.

To output the contents of the DBM file(s), Perl comes to the rescue. A colleague of mine wrote this after we searched the net for a working script and failed to find one. I’m sharing it in hopes someone will find it useful.

#!/usr/bin/perl
#- dumpdbm.pl
# /path/to/dumpdbm.pl /path/to/file.dbm
#
use SDBM_File;
use strict;
 
my ($name) = @ARGV;
die "Missing DBM name.\n" unless $name;
my %map;
tie( %map, 'SDBM_File', $name, 'O_RDONLY', 0644 ) || die "Can't open DBM file\n"; for my $k (sort(keys %map)) {
  # value is terminated by a null character, but the hash value contains cruft after that
  # so cut off the value at the first \0
  my @v = split("\0",$map{$k});
  print $k, "\t", $v[0], "\n";
}
untie %map;
exit;

The FTP client can have its default transfer type set to ASCII, Binary, or Auto. The problem seems to be resolved by setting it to Binary. If that doesn’t work, try ASCII.

But maybe the damage has already been done. Maybe it’s been downloaded and uploaded multiple times, so now the extra lines are part of the real file. Many IDEs have a tool to apply source formatting. For example in Dreamweaver, Commands->Apply Source formatting.

There are many ways/tools to remove blank lines. A quick and easy online tool may be just what you need:
http://textmechanic.com/Remove-Empty-Lines.html

http://twitter.com/
http://slashdot.org/
http://digg.com/
http://thesaurus.com/
http://nymag.com/
http://mashable.com/
http://allthingsd.com/
http://bigthink.com/
http://wordpress.org/
http://wordpress.com/
http://bbpress.org/
http://drupal.org/
http://jquery.com/
http://portableapps.com/
http://daringfireball.net/
http://stackoverflow.com/
http://meyerweb.com/
http://github.com/
http://js-kit.com/
http://clearleft.com/
http://tinyurl.com/
http://bit.ly/
http://tr.im/

And all the Gawker Media sites (running on the same platform):
http://gawker.com/
http://deadspin.com/
http://kotaku.com/
http://jezebel.com/
http://io9.com/
http://jalopnik.com/
http://gizmodo.com/
http://lifehacker.com/

CNAME

The only GOOD reason I’ve seen for being hesitant about not using ‘www’ is that you CANNOT create a CNAME record for the root domain. CNAME records are only valid when there is no other DNS for that domain, and the root domain always has other records.

As the root of a domain must have an SOA and NS records the rule above kicks in, preventing use of CNAMEs too.
http://serverfault.com/questions/170194/why-cant-a-domains-root-be-a-cname

Some Content Distribution Networks (CDN), like Akamai and Cotendo, use CNAME records as the method for one to hand over their website to the caching network. If you wanted to strictly use the root domain (no www), Akamai will tell you that you can’t due to the inability to create a CNAME record. CNAMEs are generally useful things.

There are a few ways around this:

1. Work out a special deal with the CDN to not rely on CNAME records (If Digg is really a Cotendo customer, it’s proof it can be done)
2. Use a different CDN that doesn’t require CNAME records (Anyone know any? Level 3 perhaps?)
3. Use something else. Perhaps a high power/bandwidth super intelligent load balancer.

If anyone stumbles upon this article and has details on how any of these sites are able to scale while using their root domain, please share! My work-arounds list needs some work.

By default, WordPress is lacking the functionality to handle categorized OPML feeds of links. When importing blogroll/links you are FORCED to select ONE category for ALL links to be inserted into.

My plugin adds an importer to WordPress, which is actually a modification of the standard OPML importer shipped with WP 2.7. The improved importer actually handles categories.

If the link categories already exist in your blog, links from the import within matching (case-insensitive) category names will be inserted into the correct category.

You can specify one of two options for the case where your blog doesn’t already have some categories that are found in the feed.

1) Allow it to create any new link categories needed (and insert the links into them)
2) Specify a default category that the links from unknown categories will be inserted into

I got jump start on some the coding changes a while ago here: http://www.dyers.org/blog/archives/2008/02/27/how-to-hack-the-wordpress-blogroll-importer-to-recognize-categories-from-your-feed-reader/

Until YESTERDAY there has been an item in the WordPress Trac that indicated that the milestone for its implementation in WordPress was version 2.8. I believe it would have nullified the reason for my plugin to exist. However, apparently, someone just changed the milestone from 2.8 to “Future Release (no date set)”.

So it looks like my plugin will still be useful for a long time =)

I’ve documented the steps of creating a plugin and getting it into the WordPress plugin repository here: Writing a WordPress Plugin

I discuss the plugin in a separate post: WordPress Plugin: Import Blogroll With Categories

Since this was my first official WordPress plugin, I wanted to document the procedure. Writing a plugin and going all the way with it, is not for the faint-of-heart.

First, you actually have to come up with an idea that:
1) No one has written a plugin for yet (search for it!)
2) Is doable without donating years of your life
3) Functionality you really want!

Then you actually have to create the plugin. You’ll probably have to use multiple hooks called actions and filters. I wish I could tell you there was some easy way to learn exactly which you use and how to use them, but it seems to be something you mostly have to figure out on your own. Studying the code of other plugins you like will probably help.

In PHP you can’t override user defined functions, but you CAN override all the WordPress functions defined in: wp-includes/pluggable.php. WordPress only defines the default functions if plugin defined versions don’t exist.

Various sites provide a comprehensive list of WordPress functions, classes, and variables and indicates within which files they are used and defined. WordPress provides a decent one.

Many editors (including Dreamweaver) include a method to search over all files within a directory. The feature goes by many names and is not always easy to find, but is a life-saver for tracking down functions/code.

The general WordPress plugin creation guide: http://codex.wordpress.org/Writing_a_Plugin

After your plugin has been created, relatively well tested, and refined, a whole different journey begins (if you want your plugin in the WordPress plugin repository).

I chose to put my plugin on wordpress.org because I think it is best place for WP plugins to reside. It makes the most sense to users. WP is integrated with the automatic plugin installer/updater. It serves are one solid place to look for plugins that are all documented in the same fashion. If you are serious about your plugin, I recommend you follow the required steps to get it up there.

You need to submit a request to add your plugin. The request has to approved by a person. I had to wait 2 days to get my request approved. When you make the request, make sure you use the plugin name you want to use, and a solid description.

When approved, you will get access to a SVN (Subversion) directory just for your plugin. Like this: http://svn.wp-plugins.org/name-of-your-plugin/

What they don’t clearly explain, is how to actually upload your files. The only page they refer you to is: http://wordpress.org/extend/plugins/about/svn/

Which is SOMEWHAT useful, but it is all in command-line. They make no reference to Subversion clients. When it comes to file transfer, I would prefer a nice GUI. For comparison, FTP is also a command-line based tool but we all use FTP clients don’t we?

After studying this chart of Subversion clients, I decided to try out SmartSVN (free)

I’ll admit it’s a bit overkill for updating a single plugin, but maybe I’ll use it for other SVN connections in the future. Once I got the authentication figured out (wordpress.org login), I had no problems using the program. It worked pretty much just like I expected. Easy to see if a file has been changed locally or remotely, and update the files.

SmartSVN has a ton of features, and I only used the basic stuff, so if I start using it more, perhaps I’ll write a post reviewing its features.

After uploading files (use the general guidelines here and here), you can expect to wait up to 15 minutes to see your changes reflected on http://wordpress.org/extend/plugins/

BEFORE you upload anything you’ll want to do the most important thing. To create a VERY specifically formatted readme.txt file. This readme.txt file is used to CREATE your plugins page at: http://wordpress.org/extend/plugins/your-plugin-name/

You don’t have special admin access to update that page. The page is entirely controlled by the contents of your SVN directory (especially the readme.txt).

Because the readme.txt file is so important, WordPress provided a couple nice resources. An example readme.txt file containing notes about how to format your text. And a readme.txt validator. The validator is sweet. Not only does it validate your file, but it gives you a PREVIEW of the generated HTML formatting. This preview will help you work out formatting issues before you upload anything to your SVN folder.

Remember, your plugin will be live (in about 15 minutes) after you first upload your plugin file and valid readme.txt file. So try to already have a complete and properly formatted readme.txt file before you upload anything.

If you Google for JavaScript trim functions, you’ll find that they usually use regular expressions. One would think that would be good enough. However, I encountered a situation where the typical regex whitespace trim functions simply weren’t working. Perhaps it is was an unusual whitespace character?

I found a great article that compared different JavaScript trim functions. The function he listed as “trim10″ does not use regular expressions at all. It is also one of the best performers in terms of efficiency/speed. Most importantly, this function successfully trimmed my pesky whitespace!

Sharing this fast, functional, non-regex JavaScript trim function in hopes it’ll be useful:

function trim (str) {
	var whitespace = ' \n\r\t\f\x0b\xa0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000';
	for (var i = 0; i < str.length; i++) {
		if (whitespace.indexOf(str.charAt(i)) === -1) {
			str = str.substring(i);
			break;
		}
	}
	for (i = str.length - 1; i >= 0; i--) {
		if (whitespace.indexOf(str.charAt(i)) === -1) {
			str = str.substring(0, i + 1);
			break;
		}
	}
	return whitespace.indexOf(str.charAt(0)) === -1 ? str : '';
}