Safety in Numbers

End of the line

2013-06-03T00:00:00+00:00

For almost seven years, Brighter Planet has been a constant source of inspiration for me and, I’m proud to say, for the broader sustainability community. This makes it all the more difficult to announce that the company and its Brighter Planet Visa cards and other services are coming to the end of the line.

We thank our customers, our partners, and all those with whom we’ve worked with over the years to move the needle on building a clean-energy future. It’s phenomenal how knowing what your carbon footprint is and what you can do about it or even what simple choices like which card to pull out of your wallet can do. Because of you, we offset over 350 million lbs. of CO2, supporting the development of 24 renewable energy and sustainable forestry projects across the US. This is the equivalent of over 20,000 homes being electrified by renewable energy for a year, removing over 10 million cars from the road for a day, or every cardholder turning off all the lights in their home for more than a year.

We also thank our investors, leadership boards, and experts who have supported and advised us over the years. As a business that came to be profitable with almost 200,000 customers, we hope that we have helped demonstrate, along with all of our compatriots in the social entrepreneurship world, that you can certainly do well while also doing good.

I must thank our team too, past and present, the soul of Brighter Planet. Andy, Seamus, Robbie, Ian H., Nancy, Matt K., Derek, Jon, Jake, Adam, Carolyn, Rich St., Daniel, Emily, Ashley, Bruce, David, Ian W., Kerry, Matt V., Rich Sa., Remy, and others. Some were with us for more than five years, others were interns for a few months, all played a role in our many successes.

You may be wondering why we are liquidating at this point. Having led businesses large and small, I can tell you that winding a company down is the toughest decision to make. It was not one that Brighter Planet’s Board or shareholders took lightly.

A perfect storm of regulatory upheaval made Brighter Planet’s business model increasingly challenging and financially non-sustainable going forward. The passage of the Durbin Act, intended as a plus for U.S. consumers and merchants, upended the card market, effectively precluding economically viable rewards cards that provide revenue for cause-based organizations including Brighter Planet. At the same time, the government’s inaction on meaningful cap-and-trade and the rise and fall of the U.S. carbon markets negated the need for and value of computational sustainability tools for businesses—tools that we pioneered in developing. Finally, the country’s economic meltdown these past few years naturally impacted discretionary spending by consumers and businesses, in turn impacting companies offering products and services like Brighter Planet.

Since getting our start in a Middlebury College classroom in 2005, so much has changed. The powerful call to action of An Inconvenient Truth came the year after Brighter Planet was created, and left millions of Americans searching for ways to make a difference in climate change, the most important challenge our world faces today. Back then, there weren’t many significant organizations devoted to the global warming challenge. Brighter Planet in partnership with the Bank of America and Visa offered a straightforward first step for people to reduce their impact on our planet’s atmosphere, and we appreciate the bold steps that these partners took along with us.

Now in 2013, I see a myriad of ways for people and businesses to take action. With organizations like 350.org building the largest climate movement the world has seen or CERES mobilizing business leadership for a sustainable world, I think it’s safe to say that while we certainly haven’t solved the climate problem, the community has made a serious dent in the participation problem. That you no longer need a credit or debit card to join the fight is cause for celebration.

So while Brighter Planet is wrapping up, I’m happy to count hundreds more capabilities that have sprung up from the ingenuity of the community as well as thousands of organizations both big and small that transformed themselves to embrace sustainability within their core businesses. Even several of Brighter Planet’s former employees, including one of its founders, have formed a new startup, Faraday, to apply Big Data technology to customer acquisition of energy efficiency solutions. What so many for-profits, not-for-profits, and individuals are doing today in 2013 is nothing short of amazing.

I’d like to close with some of my favorite Brighter Planet highlights from these past several years:

Managed the country’s largest consumer carbon offset program with almost 200,000 customers, outlasting every competitor in our space
Supported the development of 24 projects such as wind power in public school districts and open lands, cow power on family farms, and conservation of redwood forests, decreasing our dependence on carbon-emitting dirty energy sources like coal burning power plants and removing carbon from the atmosphere
Modeled over 27.5 million carbon, energy, and resource impacts of real-life carbon emissions sources, the most in the country
Conducted groundbreaking research in the aviation and hotel sectors, examining key drivers of energy efficiency and analyzing economic and environmental benefits
Assessed employee sustainability engagement in corporations and identified best practices
Provided grants to support community climate projects such as school gardens
Ran industry defining social media campaigns
Successfully built and sold a social giving platform
Named the country’s Best Small Business by Discovery Channel’s Treehugger
Won the Financial Times Social Innovation Award
Won the EPA’s Apps for the Environment Award
Recognized as thought leaders, presenting the company’s work to diverse audiences such as the technology, corporate travel, energy, and open government communities

Thank you all.

Patti

A new offset project

2012-09-18T00:00:00+00:00

We’ve got a new offset project, and once again it’s the first of it’s kind for Brighter Planet. The Rentech Fertilizer Plant project supports a new N₂O destruction system at midwestern fertilizer plant, and is certified under the Climate Action Reserve.

{.wrapped}

Rentech’s fertilizer plant in East Dubuque, Illinois produces nitric acid and ammonia, two of the main ingredients in fertilizer. The plant used to release Nitrous oxide (N₂O), a greenhouse gas about three hundred times more powerful than CO₂, as a byproduct of the nitric acid production process. With this project the tail gas from nitric acid production is piped through a special chamber where a catalyst converts between 95% and 99% of the N₂O into nitrogen and oxygen. A continuous emissions monitoring system directly measures the amount of N₂O in the tail gas exiting the chamber to ensure the catalyst is functioning effectively.

This project is the first of its kind in the United States and serves as an example of how the fertilizer industry can reduce the impact of its operations while continuing to serve the needs of farmers.

Learn more about the Rentech fertilizer plant or our other offset projects.

Back to the Browser - A JavaScript Workflow for UNIX Nerds

2012-09-13T00:00:00+00:00

When Apple announced Mac OS X Lion, their tagline was “Back to the Mac” as they were bringing some features from iOS into the desktop-oriented Mac OS. In the JavaScript world, a similar thing has happened: innovations in the Node.js space can be brought back to the browser. These innovations have made JavaScript development faster and cleaner with command-line tools and the npm packaging system.

As I began writing serious JavaScript libraries and apps, I wanted the same kind of workflow I enjoy when writing Ruby code. I wanted to write my code in vi, run tests in the command line, organize my code into classes and modules, and use versioned packages similar to Ruby gems. At the time, the standard way to write JavaScript was to manage separate files by hand and concatenate them into a single file. One of the only testing frameworks in town was Jasmine, which required you to run tests in the browser. Since then, there has been an explosion of command-line code packaging and testing frameworks in the Node.js community that have lent themselves well to client side development. What follows is the approach I find to be the most productive.

Here’s a list of the tools that correspond to their Ruby world counterparts:

Application	Ruby	Javascript
Testing	RSpec	vows, buster
Package management	rubygems, bundler	npm, browserify
Code organization	`require`	CommonJS
Build tools	jeweler, rubygems	browserify

By installing Node.js, you have access to a command-line JavaScript runtime, testing, package management, and application building. Running tests from the command-line allows you to more easily use tools like guard, run focused unit tests, and easily set up continuous integration.

Testing

Many JavaScripters run Jasmine in the browser for testing. While it does the job, its syntax is extremely verbose and it breaks the command-line-only workflow. There is a Node.js package for running Jasmine from the command line, but I have found it to be buggy and not as feature rich as a typical command line testing tool. Instead I prefer vows or buster.js. Each supports a simpler “hash” based syntax, as opposed to Jasmine’s verbose syntax:

// Jasmine

describe('MyClass', function() {
  describe('#myMethod', function() {
    before(function() {
      this.instance = new MyClass('foo');
    });
  
    it('returns true by default', function() {
      expect(this.instance.myMethod()).toBeTruthy();
    });
    it('returns false sometimes', function() {
      expect(this.instance.myMethod(1)).toBeFalsy();
    });
  });
});

// Vows

vows.describe('MyClass').addBatch({
  '#myMethod': {
    topic: new MyClass('foo'),

    'returns true by default': function(instance) {
      assert(instance.myMethod());
    },
    'returns false sometimes': function(instance) {
      refute(instance.myMethod(1));
    }
  }
}).export(module);

Vows and buster can be used just like rspec to run tests from the command line:

> vows test/my-class-test.js
................
OK >> 22 honored

One advantage that buster has over vows is that it can run its tests both from the command line and from a browser in case you want to run some integration tests in a real browser environment.

For mocks and stubs, you can use the excellent sinon library, which is included by default with buster.js.

Integration testing

In addition to unit testing, it’s always good run a full integration test. Since every browser has its own quirks, it’s best to run integration tests in each browser. I write cucumber tests using capybara to automatically drive either a “headless” (in-memory) webkit browser with capybara-webkit and/or GUI browsers like Firefox and Chrome with selenium.

In features/support/env.rb you can define which type of browser is used to run the tests by defining custom drivers

require 'selenium-webdriver'

    Capybara.register_driver :selenium_chrome do |app|
      Capybara::Selenium::Driver.new app, :browser => :chrome
    end

    Capybara.register_driver :selenium_firefox do |app|
      Capybara::Selenium::Driver.new app, :browser => :firefox
    end

    if ENV['BROWSER'] == 'chrome'
      Capybara.current_driver = :selenium_chrome
    elsif ENV['BROWSER'] == 'firefox'
      Capybara.current_driver = :selenium_firefox
    else
      require 'capybara-webkit'
      Capybara.default_driver = :webkit
    end

Now you can choose your browser with an environment variable: BROWSER=firefox cucumber features

If you are testing an app apart from a framework like Sinatra or Rails, you can use Rack to serve a static page that includes your built app in a <script> tag. For example, you could have an html directory with an index.html file in it:

<html>
  <head>
    <title>Test App</title>
    <script type="text/javascript" src="application.js"></script>
  </head>
  <body><div id="app"></div></body>
</html>

When you’re ready to run an integration test, compile your code into application.js using browserify:

> browserify -e lib/main.js -o html/application.js

Then tell cucumber to load your test file as the web app to test:

# features/support/env.rb
    
    require 'rack'
    require 'rack/directory'

    Capybara.app = Rack::Builder.new do
      run Rack::Directory.new(File.expand_path('../../../html/', __FILE__))
    end

Once cucumber is set up, you can start writing integration tests just as you would with Rails:

# features/logging_in.feature

Feature: Logging in

Scenario: Successful in-log
  Given I am on the home page
  When I log in as derek
  Then I should see a welcome message

# features/step_definitions/log_in_steps.rb

    Given %r{I am on the home page} do
      visit '/index.html'
    end
    
    When %r{I log in as derek} do
      click '#login'
      fill_in 'username', :with => 'derek'
      fill_in 'password', :with => 'secret'
      click 'input[type=submit]'
    end
    
    Then %r{I should see a welcome message} do
      page.should =~ /Welcome, derek!/
    end

Package management

One of the joys of Ruby is its package manager, rubygems. With a simple gem install you can add a library to your app. There has been an explosion of JavaScript package managers lately. Each one adds the basic ability to gather all of your libraries and application code, resolve the dependencies, and concatenate them into a single application file. I prefer browserify over all the others for two reasons. First, you can use any Node.js package, which opens you up to many more utilities and libraries than other managers. Second, it uses Node.js’ CommonJS module system, which is a very simple and elegant module system.

In your project’s root, place a package.json file that defines the project’s dependencies:

{
      "dependencies": {
        "JSONPath": "0.4.2",
        "underscore": "*",
        "jquery": "1.8.1"
      },
      "devDependencies": {
        "browserify": "*",
        "vows": "*"
      }
    }

Run npm install and all of your project’s dependencies will be installed into the node_modules directory. In your project you can then make use of these packages:

var _ = require('underscore'),
        jsonpath = require('JSONPath'),
        myJson = "...";

    _.each(jsonpath(myJson, '$.books'), function(book) {
      console.log(book);
    });

If you’re looking for packages available for certain tasks, simply run npm search <whatever> to find pacakges related to your search terms. Some packages are tagged with “browser” if they are specifically meant for client side apps, so you can include “browser” as one of your search terms to limit your results accordingly. Many of the old standbys, like jquery, backbone, spine, and handlebars are there.

Code organization

As JavaScript applications get more complex, it becomes prudent to split your code into separate modules, usually placed in separate files. In the Ruby world, this was easily done by require-ing each file. Node.js introduced many people (including me) to the CommonJS module system. It’s a simple and elegant way to modularize your code and allows you to separate each module into its own file. Browserify allows you to write your code in the CommonJS style and it will roll all of your code up into a single file appropriate for the browser.

Ruby structure

For example, my Ruby project may look like:

~lib/
 -my_library.rb
 -my_library/
   -book.rb
-my_library.gemspec
-spec/
 -my_library/
   -book_spec.rb

Where lib/my_library.rb looks like:

require 'my_library/book'

    class MyLibrary
      def initialize(foo)
        @book = Book.parse(foo)
      end
    end

And lib/my_library/book.rb looks like:

require 'jsonpath'

class MyLibrary
  class Book
    def self.parse(foo)
      JSONPath.eval(foo, '$.store.book\[0\]')
    end
  end
end

And spec/my_library/book_spec.rb looks like:

require 'json'
    require 'helper'
    require 'my_library/book'

    describe MyLibrary::Book do
      describe '.parse' do
        it 'parses a book object' do
          json = File.read('support/book.json')
          book = Book.parse(JSON.parse(json))
          book.title.should == "Breakfast at Tiffany's"
        end
      end
    end

JavaScript structure

A javascript project would look similar:

~lib/
 -my-library.js
 -my-library/
   -book.js
-package.json
-test/
 -my-library/
   -book-test.js

Where lib/my-library.js looks like:

var Book = require('./my-library/book');

var MyLibrary = function(foo) {
  this.book = new Book(foo);
};

module.exports = MyLibrary;

And lib/my-library/book.js looks like:

var jsonpath = require('jsonpath');

var Book = {
  parse: function(foo) {
    return jsonpath(foo, '$.store.book\[0\]');
  }
};

module.exports = Book;

And test/my-library/book-test.js looks like:

var fs = require('fs');
var helper = require('../helper'),
    Book = require('../../lib/my_library/book');
    // NOTE: there are ways to set up your modules 
    // to be able to use relative require()s but
    // it is beyond the scope of this article

vows.describe('Book').addBatch({
  '.parse': {
    'parses a book object': function() {
      var json = fs.readFileSync('support/book.json'),
          book = Book.parse(JSON.parse(json));
      assert.equal(book.title, "Breakfast at Tiffany's");
    }
  }
}).export(module);

Build tools

Browserify will build concatenated JavaScript files when you’re ready to deploy your code on a website or as a general-purpose library. Its usage is simple:

> browserify -e <main_application_startup_code> -o <path_to_built_file>

Building a library

If we were building the library in the section above, we could run browserify -e lib/my-library.js -o build/my-library.js. Then, any user of your library can use your library with the require function:

<script type="text/javascript" src="jquery.js"></script>
    <script type="text/javascript" src="my-library.js"></script>
    <script type="text/javascript">
      var myLibrary = require('my-library');
      $.ajax('/lib.json', function(data) {
        console.log(myLibrary(data));
      });
    </script>

You can also save the library user some time with a custom entry point for browsers:

// in /browser.js
    window.MyLibrary = require('my-library');

Then run browserify -e browser.js -o build/my-library.js

And the library user would use it thusly:

<script type="text/javascript" src="jquery.js"></script>
    <script type="text/javascript" src="my-library.js"></script>
    <script type="text/javascript">
      $.ajax('/lib.json', function(data) {
        console.log(MyLibrary(data));
      });
    </script>

Building a web app

A spine app might look something like:

// in app/main.js
    
    var $ = require('jquery'),
        Spine = require('spine');

    Spine.$ = $;

    var MainController = require('./controllers/main-controller');

    var ApplicationController = Spine.Controller.sub({
      init: function() {
        var main = new MainController();
        this.routes({
          '/': function() { main.active(); }
        });
      }
    });

    Spine.Route.setup({ history: true });

It would be built with browserify -e app/main.js -o build/application.js and the application.js added to your website with a <script> tag.

You can extend browserify with plugins like templatify, which precompiles HTML/Handlebar templates into your app.

Together, npm packages, command-line testing and build tools, and modular code organization help you quickly build non-trivial JavaScript libraries and applications just as easily as it was in Ruby land. I’ve developed several in-production projects using this workflow, such as our CM1 JavaScript client library, our flight search browser plugin, and hootroot.com.

Split XML files with `sgrep`, a classic UNIX utility from 1995

2012-09-11T00:00:00+00:00

sgrep is better than split or csplit for breaking up XML files by element – you can even use it to create a constant-memory streaming “parser.”

$ sgrep -o "XXXSTART%rSTOPXXX" '"<TourismEntity" .. "</TourismEntity"' transmission_file.xml
XXXSTART<TourismEntity>
    <State>New York</State>
    <Saying>I♥NY</Saying>
  </TourismEntitySTOPXXXXXXSTART<TourismEntity>
    <State>Virginia</State>
    <Saying>Is For Lovers</Saying>
  </TourismEntitySTOPXXXXXXSTART<TourismEntity>
    <State>Wisconsin</State>
    <Saying>America's Dairyland</Saying>
  </TourismEntitySTOPXXX

(see below for why that output is useful)

tl;dr

sgrep and a simple Ruby program (given below) let you stream XML elements into an #emit method that can do whatever you want. What’s more, the memory usage is constant (and small); memory usage doesn’t grow like if you parse the entire XML document into memory like with nokogiri.

Using sgrep to split XML

Combine sgrep with, for example, a Ruby program:

#!/usr/bin/env ruby

# your target element here
ELEMENT_START = '<TourismEntity'
ELEMENT_STOP = '</TourismEntity'

# your emit code here - in this case I'm just writing it to a separate file named tourism_entity-NUM.txt
def emit(tourism_entity)
  $tourism_entity_count ||= 0
  $tourism_entity_count += 1
  File.open("tourism_entity-#{$tourism_entity_count}.txt", 'w') { |f| f.write tourism_entity }
end

SGREP_BIN = %w{ sgrep sgrep2 }.detect { |bin| `which #{bin}`; $?.success? }
MAGIC_START = 'XXXSTART'
MAGIC_STOP = 'STOPXXX'

leftover = ''
IO.popen([ SGREP_BIN, '-n', '-o', "#{MAGIC_START}%r#{MAGIC_STOP}", %{"#{ELEMENT_START}" .. "#{ELEMENT_STOP}"}, ARGV[0] ]) do |io|
  while additional = io.read(65536)
    buffer = leftover + additional
    while (start = buffer.index(MAGIC_START)) and (stop = buffer.index(MAGIC_STOP))
      element_body = buffer[(start+MAGIC_START.length)...stop] + '>'
      # what "emit" does is up to you
      emit element_body
      buffer = buffer[(stop+MAGIC_STOP.length)..-1]
    end
    leftover = buffer
  end
end

So let’s go back to the example, transmission_file.xml:

<TransmissionFile>
  <TourismEntity>
    <State>New York</State>
    <Saying>I♥NY</Saying>
  </TourismEntity>
  <TourismEntity>
    <State>Virginia</State>
    <Saying>Is For Lovers</Saying>
  </TourismEntity>
  <TourismEntity>
    <State>Wisconsin</State>
    <Saying>America's Dairyland</Saying>
  </TourismEntity>
</TransmissionFile>

You will get:

$ ruby emit_tourism_entity.rb transmission_file.xml 
$ tail +1 tourism_entity-*
==> tourism_entity-1.txt <==
  <TourismEntity>
    <State>New York</State>
    <Saying>I♥NY</Saying>
  </TourismEntity>
==> tourism_entity-2.txt <==
  <TourismEntity>
    <State>Virginia</State>
    <Saying>Is For Lovers</Saying>
  </TourismEntity>
==> tourism_entity-3.txt <==
  <TourismEntity>
    <State>Wisconsin</State>
    <Saying>America's Dairyland</Saying>
  </TourismEntity>

What’s happening is:

Ruby spawns sgrep using a pipe
sgrep spits out a stream of element bodies separated by “XXXSTART” and “STOPXXX” into the pipe
Ruby reads from the pipe and watches for element bodies separated by the aforementioned magic tokens
When Ruby sees a whole element body, it runs #emit

Why are you so amazed by this program from 1995

Because just look at that beautiful syntax:

$ sgrep '"{" .. "}"' eval.c

And because memory usage is really low, and it’s really fast.

I have less than 100 elements and just want to split up the file

Both of these will break up the XML file into separate files without the need for a Ruby wrapper:

$ split -p '<TourismEntity' transmission_file.xml
$ csplit -s -k transmission_file.xml '/<TourismEntity/' '{100}'

But there are little problems, like you max out at 100 separate files (i.e. elements), and other things.

Upsert for MySQL, PostgreSQL, and SQLite3 (and Ruby)

2012-09-04T00:00:00+00:00

Our upsert library for Ruby gives you NoSQL-like upsert functionality in traditional RDBMS databases. How?

MySQL’s native INSERT ... ON DUPLICATE KEY UPDATE
PostgreSQL’s canonical CREATE FUNCTION merge_db
SQLite3’s INSERT OR IGNORE plus a trailing UPDATE statement

50%–80% faster than ActiveRecord

New in 0.4.0: When used in PostgreSQL mode, database functions are re-used, so you don’t have to be in batch mode to get the speed advantage.

You don’t need ActiveRecord to use it, but it’s benchmarked against ActiveRecord and found to be up to 50% to 80% faster than traditional techniques for emulating upsert:

# postgresql (pg library)
Upsert was 78% faster than find + new/set/save
Upsert was 78% faster than find_or_create + update_attributes
Upsert was 88% faster than create + rescue/find/update

# mysql (mysql2 library)
Upsert was 46% faster than find + new/set/save
Upsert was 63% faster than find_or_create + update_attributes
Upsert was 74% faster than create + rescue/find/update
Upsert was 28% faster than faking upserts with activerecord-import (which uses ON DUPLICATE KEY UPDATE)

# sqlite3
Upsert was 72% faster than find + new/set/save
Upsert was 74% faster than find_or_create + update_attributes
Upsert was 83% faster than create + rescue/find/update

(run the tests on your own machine to get these benchmarks)

What is a selector? What is a document?

upsert was inspired by the MongoDB upsert method – AKA mongo-ruby-driver’s update method – and involves a “selector” (how to find the row to be inserted or updated) and a “document” (attributes that should be set once the record has been found.)

Example 1

Selector: :name => 'Jerry'
Document: :age => 5
Expression: upsert.row({:name => 'Jerry'}, :age => 5)

Example 2

Selector: :id => 45
Document: :updated_at => Time.now
Expression: upsert.row({:id => 45}, :updated_at => Time.now)

Unfortunately, you currently can’t do things like :counter => 'counter + 1'.

Quickstart

One record at a time:

connection = Mysql2::Client.new([...])
upsert = Upsert.new connection, 'pets'
upsert.row({:name => 'Jerry'}, :breed => 'beagle')

With ActiveRecord helper: (first require 'upsert/active_record_upsert')

Pet.upsert({:name => 'Jerry'}, :breed => 'beagle')

In batch mode, which is the fastest:

connection = Mysql2::Client.new([...])
Upsert.batch(connection, 'pets') do |upsert|
  upsert.row({:name => 'Jerry'}, :breed => 'beagle')
  upsert.row({:name => 'Pierre'}, :breed => 'tabby')
end

Graphite and statsd – beyond the basics

2012-08-27T00:00:00+00:00

The Graphite and statsd systems have been popular choices lately for recording system statistics, but there isn’t much written beyond how to get the basic system set up. Here are a few tips that will make your life easier.

Graphite + statsd - the rundown

The graphite and statsd system consists of three main applications

carbon: a service that receives and stores statistics
statsd: a node server that provides an easier and more performant, UDP-based protocol for receiving stats which are passed off to carbon
graphite: a web app that creates graphs out of the statistics recorded by carbon

Use graphiti

Several alternative front-ends to graphite have been written. I chose to use graphiti because it had the most customizable graphs. Note that graphiti is just a facade on top of graphite - you still need the graphite web app running for it to work. Graphiti makes it easy to quickly create graphs. I’ll cover this later.

The flow looks like:

|App| ==[UDP]==> |statsd| ==> |carbon| ==> |.wsp file|

|.wsp file| ==> |graphite| ==> |graphiti| ==> |pretty graphs on your dashboard|

Use chef-solo to install it

If you’re familiar with chef, you can use the cookboos that the community has already developed for installing graphite and friends. If not, this would be a good opportunity to learn. You can use chef-solo to easily deploy graphite to a single server. I plan to write a “getting started with chef-solo” post soon, so stay tuned!

Chef saved me a ton of time setting up python, virtualenv, graphite, carbon, whisper, statsd, and many other tools since there are no OS-specific packages for some of these.

Use sensible storage schemas

The default chef setup of graphite stores all stats with the following storage schema rule:

[catchall]
priority = 0
pattern = ^.*
retentions = 60:100800,900:63000

The retentions setting is the most important. It’s a comma-delimited list of data resolutions and amounts. * The number before the colon is the size of the bucket that holds data in seconds. A value of 60 means that 60 seconds worth of data is grouped together in the bucket. A larger number means the data is less granular, but more space efficient. * The number after the colon is the number of data buckets to store at that granularity. 100800 will cover (100800 * 60) = 70 days of data. That’s (100800 * 12) = 1.2MiB of space for those 70 days. A bigger number means more disk space and longer seek times.

Alternatively, you can specify retentions using time format shortcuts. For example, 1m:7d means “store 7 days worth of 1-minute granular data.”

Use a good stats client

In the ruby world, there are two popular client libraries: fozzie and statsd-ruby. Both provide the standard operations like counting events, timing, and gauging values.

Fozzie differs in that it integrates with Rails or rack apps by adding a rack middleware that automatically tracks timing statistics for every path in your web app. This can save time, but it also has the downside of sending too much noise to your statsd server and can cause excessive disk space consumption unless you implement tight storage schema rules. It also adds a deep hierarchy of namespaces based on the client machine name, app name, and current environment. This can be an issue on heroku web apps where the machine name changes frequently.

If you want more control over your namespacing, statsd-ruby is the way to go. Otherwise, fozzie may be worth using for its added conveniences.

Make sure you don’t run out of disk space

Seriously, if you do run out of disk, the graphite (whisper) data files can become corrupted and force you to delete them and start over. I learned this the hard way :) Make sure your storage schemas are strict enough because each separate stat requires its own file that can be several megabytes in size.

Use graphiti for building graphs and dashboards

Graphiti has a great interface for building graphs. You can even fork it and deploy your own custom version that fits your company’s needs and/or style. It’s a small rack app that uses redis to store graph and dashboard settings. There’s even a chef cookbook for it!

When setting up graphiti, remember to set up a cron job to run rake graphiti:metrics periodically so that you can search for metric namespaces from graphiti.

Use graphite’s built-in functions for summarizing and calculating data

Graphite provides a wealth of functions that run aggregate operations on data before it is graphed.

For example, let’s say we’re tracking hit counts on our app’s home page. We’re using several web servers for load balancing and our stats data is namespaced by server under stats.my_app.server-a.production.home-page.hits and stats.my_app.server-b.production.home-page.hits. If we told graphite to graph results for stats.my_app.*.production.home-page.hits we would get two graph lines – one for server-a and one for server-b. To combine them into a single measurement, use the sumSeries function. You can then use the alias function to give it a friendlier display name like “Home page.”

Graphiti has a peculiar way of specifying which function to use. In a normal series list, you have the following structure:

"targets": [
  [
    "stats.my_app.*.production.home-page.hits",
    {}
  ]
]

The {} is an object used to specify the list of functions to apply, in order, on the series specified in the parent array. Each graphite function is specified as a key and its parameters as the value. A true value indicates the function needs no parameters and an array is provided if the function requires multiple parameters.

You’ll notice in the function documentation that each function usually takes two initial arguments, a context and a series name. In graphiti, you won’t need to specify those first two arguments.

Here’s an example of sumSeries and alias used together. Note that the order matters!

"targets": [
  [
    "stats.my_app.*.production.home-page.hits",
    {
      "sumSeries": true,
      "alias": "Homepage hits"
    }
  ]
]

Different graph areaMode for different applications

While not well documented, graphite has a few options for displaying graph lines. By default, the “stacked” area mode stacks each measurement on top of each other into an area chart that combines multiple measurements that are uniquely shaded. This can be good for seeing grand totals. The blank option plots each measurement as a line on a line chart. This is preferable for comparing measurements.

Different metrics for different events

Each stats recording method provided by statsd-ruby and fozzie has different behavior, which isn’t well documented anywhere.

Stats.count is the base method for sending a count of some event for a given instance. It’s rarely used alone.
Stats.increment and Stats.decrement will adjust a count of an event. It’s useful for counting things like number of hits on a page, number of times an activity occurs, etc. It will be graphed as “average number of events per second”. So if your web app runs Stats.increment 'hits' 8 times over a 1 second period, the graph will draw a value of 8 for that second. Sometimes you will see fractional numbers charted. This is because graphite may average the data over a time period based on your schema storage settings and charting resolution.
Stats.timing will take a block and store the amount of time the code in the block took to execute. It also keeps track of average, min, and max times, as well as standard deviation and total number of occurrences.
Stats.gauge tracks absolute values over time. This is useful for tracking measurements like CPU, memory, and disk usage.
Fozzie provides Stats.event 'party' to track when an event happens. This is useful for tracking things like deploys or restarts. Equivalent functionality can be obtained in statsd-ruby by running Stats.count 'party', Time.now.to_i.

Bonus tip: Graphs on your Mac dashboard

If you’re using a mac, you can add your favorite graphs to your dashboard. Create a graph in graphiti, then view it on the graphiti dashboard with Safari. Click File->Open in Dashboard… and select the graph image with the select box. Now, you can quickly see important graphs at the press of a button!

Overall, statsd is a great tool and can add great visibility into your applications.

Analyze CREATE TABLE SQL with pure Ruby

2012-08-27T00:00:00+00:00

You can use the new create_table library to analyze and inspect CREATE TABLE statements (what is the primary key? what are the column data types? what are the defaults?) You can also generate SQL that works with different databases.

>> require 'create_table'
=> true
>> c = CreateTable.new(%{
  CREATE TABLE employees
  (employeeid INTEGER NOT NULL,
  lastname VARCHAR(25) NOT NULL,
  firstname VARCHAR(25) NOT NULL,
  reportsto INTEGER NULL); 
})
=> #<CreateTable>
>> c.columns.map(&:name)
=> ["employeeid", "lastname", "firstname", "reportsto"]
>> c.columns.map(&:data_type)
=> ["INTEGER", "CHARACTER VARYING(25)", "CHARACTER VARYING(25)", "INTEGER"]
>> c.columns.map(&:allow_null)
=> [false, false, false, true]

(grabbed that example from the About.com entry on CREATE TABLE SQL, thanks!)

Uses Ragel for parsing

The library uses Ragel internally for parsing.

Check out the column parser code, for example.

Translates among MySQL, PostgreSQL, and SQLite3

Early versions target MySQL, PostgreSQL, and SQLite.

>> require 'create_table'
=> true
>> c = CreateTable.new(%{
  CREATE TABLE cats (
    id INTEGER AUTO_INCREMENT, /* AUTO_INCREMENT with an underscore is MySQL-style... */
    nickname CHARACTER VARYING(255),
    birthday DATE,
    license_id INTEGER,
    price NUMERIC(5,2),
    PRIMARY KEY ("id")
  )
})
=> #<CreateTable>
>> c.to_mysql
=> ["CREATE TABLE cats ( `id` INTEGER PRIMARY KEY AUTO_INCREMENT, nickname CHARACTER VARYING(255), birthday DATE, license_id INTEGER, price NUMERIC(5,2) )"]
>> c.to_postgresql
=> ["CREATE TABLE cats ( \"id\" SERIAL PRIMARY KEY, nickname CHARACTER VARYING(255), birthday DATE, license_id INTEGER, price NUMERIC(5,2) )"]
>> c.to_sqlite3
=> ["CREATE TABLE cats ( \"id\" INTEGER PRIMARY KEY AUTOINCREMENT, nickname CHARACTER VARYING(255), birthday DATE, license_id INTEGER, price NUMERIC(5,2) )"]

Obviously there’s a web service

You can POST statements to http://create-table.herokuapp.com/statements and get the results back as JSON:

$ curl -i -X POST -H "Accept: application/json" --data "CREATE TABLE cats ( id INTEGER AUTO_INCREMENT, nickname CHARACTER VARYING(255), birthday DATE, license_id INTEGER, price NUMERIC(5,2), PRIMARY KEY (\"id\") )" http://create-table.herokuapp.com/statements
HTTP/1.1 201 Created
Cache-Control: max-age=0, private, must-revalidate
Content-Type: application/json; charset=utf-8
Date: Fri, 24 Aug 2012 22:24:52 GMT
Etag: "f13513b9126eb1fb909229e828c6a7cd"
Location: http://create-table.herokuapp.com/statements/9
Server: thin 1.4.1 codename Chromeo
X-Rack-Cache: invalidate, pass
X-Runtime: 0.051092
X-Ua-Compatible: IE=Edge,chrome=1
Content-Length: 1490
Connection: keep-alive

{"statement":{"original":"CREATE TABLE cats ( id INTEGER AUTO_INCREMENT, nickname CHARACTER VARYING(255), birthday DATE, license_id INTEGER, price NUMERIC(5,2), PRIMARY KEY (\"id\") )","mysql":"CREATE TABLE cats ( `id` INTEGER PRIMARY KEY AUTO_INCREMENT, nickname CHARACTER VARYING(255), birthday DATE, license_id INTEGER, price NUMERIC(5,2) )","postgresql":"CREATE TABLE cats ( \"id\" SERIAL PRIMARY KEY, nickname CHARACTER VARYING(255), birthday DATE, license_id INTEGER, price NUMERIC(5,2) )","sqlite3":"CREATE TABLE cats ( \"id\" INTEGER PRIMARY KEY AUTOINCREMENT, nickname CHARACTER VARYING(255), birthday DATE, license_id INTEGER, price NUMERIC(5,2) )","columns":[{"name":"id","data_type":"INTEGER","allow_null":false,"default":null,"primary_key":true,"unique":true,"autoincrement":true,"charset":null,"collate":null},{"name":"nickname","data_type":"CHARACTER VARYING(255)","allow_null":true,"default":null,"primary_key":false,"unique":false,"autoincrement":false,"charset":null,"collate":null},{"name":"birthday","data_type":"DATE","allow_null":true,"default":null,"primary_key":false,"unique":false,"autoincrement":false,"charset":null,"collate":null},{"name":"license_id","data_type":"INTEGER","allow_null":true,"default":null,"primary_key":false,"unique":false,"autoincrement":false,"charset":null,"collate":null},{"name":"price","data_type":"NUMERIC(5,2)","allow_null":true,"default":null,"primary_key":false,"unique":false,"autoincrement":false,"charset":null,"collate":null}]}}

Submissions are recorded so that you can add errata to them—like this one.

Madison Ruby Conf 2012 Healthy Hacker Fun Run

2012-08-23T00:00:00+00:00

Thanks to those who showed up for the Fun Run! Photos coming soon.

How to parse quotes in Ragel (and Ruby)

2012-08-21T00:00:00+00:00

The key to parsing quotes in Ragel is ([^’\] | /\./)* as found in the rlscan example. Think of it as ( not_quote_or_escape | escaped_something )*.

Making it work with single and double quotes

Here’s the heart of a working example that covers both single and double quotes:

%%{
  machine not_scanner;

  action Start {
    s = p
  }
  action Stop {
    quoted_text = data[s...p].pack('c*')
    # do something with the quoted text!
  }

  squote = "'";
  dquote = '"';
  not_squote_or_escape = [^'\\];
  not_dquote_or_escape = [^"\\];
  escaped_something = /\\./;
  ss = space* squote ( not_squote_or_escape | escaped_something )* >Start %Stop squote;
  dd = space* dquote ( not_dquote_or_escape | escaped_something )* >Start %Stop dquote;

  main := (ss | dd)*;
}%%

Why does it work?

Use this example string:

"a\"bc"

Follow it on the graph: (notice the symmetry… the “top” processes double quotes and the “bottom” processes single quotes)

… tl;dr …

   "      a     \     "     b      c      "
➇  →  ➁  →  ➂  →  ➃  →  ➂  →  ➂  →  ➂  →  ➇
                     BAM!

State ➃ is eating the escaped double quote and therefore preventing the machine from stopping—that’s the key!

You can also do it with a scanner

Here’s what you would do in a scanner:

%%{
  machine scanner;

  action GotOne {
    quoted_text = data[(ts+1)...(te-1)].pack('c*')
    # do something with quoted text!
  }

  squote = "'";
  dquote = '"';
  not_squote_or_escape = [^'\\];
  not_dquote_or_escape = [^"\\];
  escaped_something = /\\./;

  main := |*
    squote ( not_squote_or_escape | escaped_something )* squote => GotOne;
    dquote ( not_dquote_or_escape | escaped_something )* dquote => GotOne;
    any;
  *|;
}%%

Simple, clean reports in Ruby

2012-07-20T00:00:00+00:00

Our report library for Ruby is the shortest path between

mysql> select * from employees;
+----+------------+-----------+---------+------------+---------+
| id | first_name | last_name | salary  | birthdate  | role    |
+----+------------+-----------+---------+------------+---------+
|  1 | Deirdre    | Irish     |   45000 | 1960-09-10 | Liaison |
|  2 | Gregor     | German    | 16000.5 | 1950-09-09 | Tech    |
|  3 | Spence     | Scot      |    5000 | 1955-12-11 | Joker   |
|  4 | Vincent    | French    | 8000.99 | 1947-04-17 | Fixer   |
|  5 | Sam        | American  | 16000.5 | 1930-04-02 | Planner |
+----+------------+-----------+---------+------------+---------+

and simple, clean reports like

90% of the way by default

Did you notice these little details?

Business-class typography: Arial 10pt, left-aligned text and dates, right-aligned numbers and currency
Auto-fit to contents: always enabled
Autofilters: always added to your column headers
Freeze pane: always frozen beneath your column headers

Here’s the code that generated it:

class Tps < Report
  table 'Hierarchy' do
    head do
      row 'TPS code', :code
      row 'Date', :date
      row 'Section', 'Hierarchy'
    end
    body do
      rows :employees, ['last_name ASC']
      column('Full name') { first_name + ' ' + last_name }
      column 'Role'
      column 'Salary', :type => :Currency
    end
  end
  table 'Seniority' do
    head do
      row 'TPS code', :code
      row 'Date', :date
      row 'Section', 'Seniority'
    end
    body do
      rows :employees, ['birthdate DESC']
      column('Full name') { first_name + ' ' + last_name }
      column 'Birthdate'
      column 'Over 70?'
    end
  end
  attr_reader :code
  def initialize(code)
    @code = code
  end
  def employees(order)
    Employee.order(order).each { |employee| yield employee }
  end
  def date
    Date.today
  end
end

And here’s how you generate it:

>> t = Tps.new('ABC123')
=> #<Tps:0x00000101426998 @code="ABC123">
>> t.xlsx.path
  Employee Load (36.1ms)  SELECT `employees`.* FROM `employees` ORDER BY last_name ASC
  Employee Load (0.3ms)  SELECT `employees`.* FROM `employees` ORDER BY birthdate DESC
=> "/var/folders/Nm/Nm0HFsHAH90Zyt7NLDUZUE+++TI/-Tmp-/133538737_Report__Xlsx.xlsx"
>> t.pdf.path
  Employee Load (0.2ms)  SELECT `employees`.* FROM `employees` ORDER BY last_name ASC
  Employee Load (0.1ms)  SELECT `employees`.* FROM `employees` ORDER BY birthdate DESC
=> "/var/folders/Nm/Nm0HFsHAH90Zyt7NLDUZUE+++TI/-Tmp-/133548261_Report__Pdf.pdf"
>> t.csv.paths
  Employee Load (0.3ms)  SELECT `employees`.* FROM `employees` ORDER BY last_name ASC
  Employee Load (0.2ms)  SELECT `employees`.* FROM `employees` ORDER BY birthdate DESC
=> ["/var/folders/Nm/Nm0HFsHAH90Zyt7NLDUZUE+++TI/-Tmp-/133553761_Report__Csv__Table_Hierarchy.csv", "/var/folders/Nm/Nm0HFsHAH90Zyt7NLDUZUE+++TI/-Tmp-/133553767_Report__Csv__Table_Seniority.csv"]

You get paths to files in the tmp dir. Only the CSV output format gives you multiple files.

Three output formats: XLSX, PDF, and CSV

You’ve already seen the XLSX output format - it’s currently the most advanced.

The PDF output format starts each table on its own page:

The CSV output format puts each table into its own file:

TPS code,ABC123
Date,2012-07-19
Section,Hierarchy

Full name,Role,Salary
Sam American,Planner,16000.5
Vincent French,Fixer,8000.99
Gregor German,Tech,16000.5
Deirdre Irish,Liaison,45000.0
Spence Scot,Joker,5000.0

tps0.csv tps1.csv

How the DSL works

See the following for a line-by-line analysis…

# don't forget to inherit from Report
class Tps < Report

  # this is the sheet name in excel
  table 'Hierarchy' do

    head do
      # calling Tps#code
      row 'TPS code', :code

      # calling Tps#date
      row 'Date', :date

      # no calls are made
      row 'Section', 'Hierarchy'
    end

    body do
      # Tps#employees('last_name ASC')
      rows :employees, ['last_name ASC']

      # instance_eval'ing the proc on Employee... getting Employee#first_name + ' ' + Employee#last_name
      column('Full name') { first_name + ' ' + last_name }

      # Employee#role
      column 'Role'

      # formatted as currency where available (currently only XLSX output)
      column 'Salary', :type => :Currency
    end
  end

Header and footer print styles

You can apply formatting to the XLSX and PDF output formats according to what the underlying libraries support:

class Tps < Report
  # [...]

  # Where 72 = 1 inch
  format_pdf(
    :stamp => File.expand_path('../acme_letterhead/report_template_landscape.pdf', __FILE__),
    :body => { :width => (10*72), :header => true },
    :document => {
      :top_margin => 118,
      :right_margin => 36,
      :bottom_margin => 72,
      :left_margin => 36,
      :page_layout => :landscape,
    }
  )

  # Whatever is supported by https://github.com/seamusabshere/xlsx_writer
  format_xlsx do |xlsx|
    xlsx.quiet_booleans!
    acme_logo = xlsx.add_image(File.expand_path('../acme_letterhead/acme_logo.emf', __FILE__), 118, 107)
    acme_logo.croptop = '11025f'
    acme_logo.cropleft = '9997f'
    brighterplanet_logo = xlsx.add_image(File.expand_path('../acme_letterhead/brighterplanet_logo.emf', __FILE__), 116, 36)
    xlsx.header.left.contents = acme_logo
    xlsx.header.right.contents = 'Corporate TPS Reporting Program'
    xlsx.footer.left.contents = 'Confidential'
    xlsx.footer.center.contents = [ 'Powered by ', brighterplanet_logo ]
    xlsx.footer.right.contents = :page_x_of_y
    xlsx.page_setup.top = 1.5
    xlsx.page_setup.header = 0
    xlsx.page_setup.footer = 0
  end
end

Wishlist

Finalize the DSL - do you like it?
Finish documenting all the methods
Make sure XLSX output format renders on all versions of Microsoft Office above 2007

The Green Button that could have been

2012-07-18T00:00:00+00:00

What’s the first step in discovering efficiency opportunities? Data, data, data. That’s what we always say here at Brighter Planet, where we’re trying to compute our way to a more hopeful environmental future.

So I’m sure it won’t surprise you when I say that the key to the energy challenge also starts with data: how much we’re using and when and where we’re using it. Which makes it all the more poignant to write this critique of the much-lauded Green Button program, which ostensibly is all about opening up energy data.

The truth is that Green Button, as a government advocacy program, has not succeeded in unleashing the gold rush of energy efficiency magic we know is locked up in the heads of entrepreneurs. Developers aren’t building apps, consumers aren’t using them, and utilities aren’t playing ball. Frankly it’s hard to blame them. Luckily there’s a better way to do Green Button, using modern technology to truly empower energy consumers in a lasting, meaningful way. But first . . .

Back to the beginning

Green Button started as a gleam in U.S. CTO Aneesh Chopra’s eye. At the GridWeek2011 Smart Grid event, Aneesh challenged the energy industry to provide consumers with a “green button” you can click to download detailed energy use data. Here’s the bit from his keynote:

His oratory is certainly inspiring, and, had I been there, I would have been roused to standing applause. But now I can’t help but wonder if the seasoned (grizzled?) energy infrastructure veterans in the crowd immediately saw the flaws in the Green Button challenge.

I’ve met Aneesh twice (at Strata and then later at CleanWebHackathon) and both times said to myself, here is a sharp guy. In conversation he is refreshingly blunt and he clearly does not put up with nonsense.

So although Green Button is now deserving of this critique, I do not believe Aneesh intended for it to be the empty tease it is today. As he said himself in the keynote, “Nothing’ll be perfect on day one,” and so, in that spirit, I will explain where I think this simple promising concept went so completely wrong.

Buttons galore

If you rewind the video a bit, you’ll see that before Aneesh issues his challenge, he describes a program called Blue Button, launched at the Veterans Administration, that allows patients to download their medical history with the proverbial click of a blue button.

Using the VA program as inspiration was Green Button’s original sin. If you look at Blue Button promotional materials, you’ll find phrases like “human readable” and “easy-to-read.” Sure, we can program computers to interpret Blue Button files, but their primary purpose is to inform humans. Don’t believe me? Take a look at a sample file:

Allergy Name: Pollen
Date:         18 Mar 2010
Severity:     Mild    
Diagnosed:    Yes

Reaction: Watery eyes, itchy nose 

Comments: Took an over the counter antihistamine

Eyes watering yet?

A smart move

One thing Green Button got right was its data exchange format. Even though the data we’re talking about sounds simple (just a bunch of meter readings with timestamps) there has to be an agreed-upon way to serialize this data, and it turns out there’s an existing standard—NAESB’s ESPI—for doing just that.

Green Button’s adoption of ESPI was an excellent step in the right direction. The data files are really quite simple to parse and use with existing tools. It would have been all too easy to follow Blue Button too closely and specify a newline-delimited or otherwise “human readable” file format. Although who knows what your average human would be able to do with this:

2012-03-01 00:00 to 2012-03-01 00:15 0.302 kWh $0.01
2012-03-01 00:15 to 2012-03-01 00:30 0.302 kWh $0.01
2012-03-01 00:30 to 2012-03-01 00:45 0.302 kWh $0.01
2012-03-01 00:45 to 2012-03-01 01:00 0.302 kWh $0.01
2012-03-01 01:00 to 2012-03-01 01:15 0.302 kWh $0.01
2012-03-01 01:15 to 2012-03-01 01:30 0.302 kWh $0.01
2012-03-01 01:30 to 2012-03-01 01:45 0.302 kWh $0.01
2012-03-01 01:45 to 2012-03-01 02:00 0.302 kWh $0.01
2012-03-01 02:00 to 2012-03-01 02:15 0.302 kWh $0.01
2012-03-01 02:15 to 2012-03-01 02:30 0.302 kWh $0.01
2012-03-01 02:30 to 2012-03-01 02:45 0.302 kWh $0.01

Manual labor

With a human endpoint in mind, Blue Button’s “download this file to your computer and use it how you’d like” interaction model makes perfect sense. Patients will likely email the file to their doctor or print it out and bring it to an appointment.

But with energy data, where real value comes from continuous computer analysis, this model is truly inappropriate. Here’s what I, as an energy consumer, must do to leverage the Green Button program:

Discover an interesting energy app
Open a new tab
Find my utility’s website
Log in
Find the green button (if it exists!) and click it
Choose a place on my computer to save the file
Go back to the first tab
Click the app’s “upload” link
Find the location I saved by data file on my computer

I’ll admit this list is a bit verbose, but you get my point: it’s a bore. The energy app in step 1 is going to have be incredibly interesting to drive a user through this interaction. And here’s the really awful part: you have to go through all of these steps every time you want your energy app to have access to new data.

Imagine if in order to use Mint.com you had to visit every one of your online banking accounts every morning, download exports of your transactions, and upload them to your Mint.com profile. That’s what we’re dealing with when it comes to today’s Green Button.

To put it simply, this is just an unworkable model for developers for anything beyond experimentation. It’s ridiculous to expect your users to go through this process (repeatedly) to draw value from your application, which means a user base of approximately zero, which means a revenue stream of roughly the same amount.

I’ll be honest that my first reaction to hearing about the Apps for Energy contest was to be a bit insulted. Why should developers spend their valuable time building software on a platform that by its very nature precludes meaningful, lasting user relationships? Well, at least there were cash prizes.

A way forward

What we need is a system that allows us to tell our utility that it’s OK for an energy app we like to have ongoing access to our electricity usage data. This is how we’re able to allow apps like Tweetdeck to look at our Twitter feeds without downloading all of our tweets from Twitter and uploading them to Tweetdeck. It’s how we can add apps to our Facebook accounts that do cool things with our social data.

This paradigm—applications talking to other applications, about us, with our permission—is the enduring reward of Web 2.0, and it’s exactly what we need in energy land.

If we can achieve this, it won’t look much like today’s Green Button at all. We’d probably stick with ESPI for data exchange, but there wouldn’t even be a “green button” involved. (Recall that to add an app to a given platform, you start with the app, which send you over to a “yes/no” authorization page on the platform.)

There’s already a time-tested, secure, best-practice way of doing this (OAuth) that will allow energy app developers to accept data in a universal format with a common authorization process, regardless of the user’s utility. All the developer will need is a database listing the OAuth endpoints for each utility in the country.

Making the case

And, of course, that’s the rub. Adoption by utilities of the Green Button program has been underwhelming to say the least: only five have actually posted the clickable green button to their sites. I don’t think we can ask each utility to voluntarily expose a usage data endpoint via OAuth authentication and expect a more enthusiastic response.

I know that Aneesh liked to fly a bit below the radar (alas he’s not CTO anymore), championing solutions that don’t require budget outlays, laws, executive orders, or political dogfights. But this is a place where we really need government direction: all U.S. electric utilities should be required to offer ESPI data at an OAuth endpoint by Jan. 1, 2014.

Meanwhile

But of course we developers don’t like to sit still. Theoretically we could build a proxy system that automatically “logs in” to utility accounts, downloads Green Button data, and feeds this data to authorized applications on the user’s behalf.

This is what we did with Sparkwire, and boy was it a bear. We were only able, in fact, to produce a driver for one utility—PG&E—and for that we had to whip out the nuclear weapon of application integration: screen scraping. Behold:

What a mess. And we’d have to do this for each and every utility around the country that we want to support. But in the end, I suppose, that’s better than expecting every one of our users to go through the download/upload song-and-dance every time they wanted some new insight.

In conclusion

If we truly want to empower energy consumers, we must replace Green Button’s “download/upload” torture with a modern, OAuth-powered “app and platform” model. To do this, we either have to prevail upon utilities nationwide to get with the program, or we use a proxy like Sparkwire and write drivers for the 3,000-odd electric utilities around the country.

Either way, it’s daunting. But it’s gotta happen. Who’s in?

P.S.

How incredible is it that they’re even thinking about something as obscure as energy use data exchange formats in the top advisory levels of the White House? Heady times!

My CompSust'12 Presentation

2012-07-12T00:00:00+00:00

Here are the slides from my talk on our Flight emitter at CompSust’12.

I basically gave a quick overview of the model and then summarized some findings from the Air Travel Carbon and Energy Efficiency paper we released last year.

People were surprised that so much variation in flight efficiency exists since airlines have a financial incentive to reduce fuel use. They were also interested in how much of the variation was due to seat configuration and wondered to what extent the average passenger would support increased efficiency at the cost of smaller seats.

Our Careplane browser plugin was a big hit, and a few people asked if we could extend it into an intermodal comparison tool.

I also presented this poster at the poster session.

CompSust'12

2012-07-10T00:00:00+00:00

I’m just back from the 3rd international conference on computational sustainbality in Copenhagen, Denmark. A beautiful scandinavian city, a jazz festival, and the latest on using machine learning and linear programming to develop intelligent energy management systems, integrate electric vehicles into the electricity grid, and optimize logistics - who could ask for more?

One of the things I liked was the conference’s size. At a bit less than 100 people it was big enough to have a variety of sessions but small enough that you could track down anyone you’d missed or had questions for. It was also a refreshing change to go to an academic conference as opposed to a professional one.

Some of the presentations I particularly enjoyed included:

Developing an intelligent system that automatically learns the characteristics of your home and your energy use patterns and then provides energy-saving tips (Nick Jennings).

A model that improves short-term local wind forecasts by analysing spatio-temporal correlations in forecast versus actual wind speed across all of Denmark (Julija Tastu).

Optimizing purchasing and distribution logistics for biomass power plants (Niels Kjeldsen).

Automating the repositioning a shipping fleet (Kevin Tierney).

Predicting future vegetation cover in the arctic (Theo Damoulas).

All in all a great summary of how computational techniques are being applied to sustainability issues.

A Deep Dive Into the New Automobile Emitter

2012-06-21T00:00:00+00:00

We’ve made some exciting changes to our automobile emitter. Let’s take a look!

All the fuels

We now support automobile variants like flex fuel and diesel vehicles. If you want to specify, for instance, a flex fuel Ford F-150, you can specify “FFV” as part of the model name, as in this query:

http://impact.brighterplanet.com/automobiles?make=Ford&modelF150 FFV&year=2012

Alternatively, you can specify an automobile_fuel and the correct model will be used by CM1:

http://impact.brighterplanet.com/automobiles?make=Ford&modelF150&year=2012&automobile_fuel=E85

Alternative fuels like electricity, compressed natural gas (CNG) and hydrogen are also supported. One of the most difficult tasks facing anyone trying to calculate automobile emissions is to convert from the EPA’s miles per gallon rating to alternative fuel consumption, then convert that fuel value to emissions. We do this all for you, all you need to tell us is distance travelled.

For electric cars, if you specify a country, we will use that country’s average emissions from electricity generation. Otherwise, a global average is used.

Activity Years

We now keep track of “activity years” which determine a range of years that an automobile is used. What this means is that when you say “I drove a Volkswagen Rabbit in 2010,” we can get the average emissions for a typical Rabbit that would have been in use in 2010.

Using distance-based emission factors

Previously, we had used per-unit-fuel emission factors like “0.23 kilograms of CO2 per liter of gasoline.” Now we follow EPA’s GHG inventory methodology which calculates the amount of CO2 per unit of distance. This better takes an automobile’s engine characteristics and air conditioning use into account.

As always, we are available for support in using CM1. If you’re on IRC, you can join us in the #brighterplanet room. You can also email us at info@brighterplanet.com or tweet us @brighterplanet.

Striving for a great API client

2012-06-19T00:00:00+00:00

I wanted to take a moment to share some of the principles and technologies we used to build client libraries for our CM1 web service. As developers, we know how frustrating it can be to learn a new API and we keep that in mind as we design our client libraries to spare others of the same frustration.

Make the API client simple

Give first-time developers early wins by avoiding signups. Don’t waste developers’ time with weird object instantiation patterns. A good API is one that takes very little configuration and setup. If I want to run a query, I want to do it with as few lines of code as possible. With our carbon gem you can be up and running with a single function call:

result = Carbon.query('Flight', {
      :origin_airport => 'MSN',
      :destination_airport => 'ORD'
    })
    puts "Carbon for my cross country flight: #{result.carbon}"

No account setup is needed until you’re in production. Once you’re ready, you can sign up for an API key and set it:

Carbon.key = 'MyKeyABC'

Our JavaScript client works similarly:

var CM1 = require('cm1');
    CM1.impacts('flight', {
      origin_airport: 'IAD',
      destination_airport: 'PDX'
    },
    function(err, impacts) {
      console.log('Carbon for my cross-country flight: ',
                  impacts.carbon);
    });

Another benefit of a simple API is that it’s easier to mock out when testing an application against it.

Craft well-written documentation

Document your client library’s code, README, and website. Never assume a new user is familiar with all of the terminology your API uses and explain it well. Note that the simpler your API is, the easier it’ll be to write documentation.

Ruby docs with YARDoc

You may be familiar with Ruby’s RDoc documentation generator. YARDoc is similar, but adds some handy directives that better format your documentation.

The @param directive - @param [<type>] <name> <description> - defines a parameter that a function accepts.

The @return directive - @return [<type>] - specifies the return value of the function.

Each @overload directive @overload <function>(<param>) tells YARDoc that the function can be called with different method signatures.

Here’s an example from the carbon gem:

# @overload query(emitter, params)
    #   The simplest form.
    #   @param [String] emitter The {http://impact.brighterplanet.com/emitters.json emitter name}.
    #   @param [optional, Hash] params Characteristics like airline/airport/etc., your API key (if you didn't set it globally), timeframe, compliance, etc.
    #   @return [Hashie::Mash] The API response, contained in an easy-to-use +Hashie::Mash+
    #
    # @overload query(obj)
    #   Pass in a single query-able object.
    #   @param [#as_impact_query] obj An object that responds to +#as_impact_query+, generally because you've declared {Carbon::ClassMethods#emit_as} on its parent class.
    #   @return [Hashie::Mash] The API response, contained in an easy-to-use +Hashie::Mash+
    def Carbon.query(*params)

And here’s the YARDoc output:

These directives are important for dynamically typed languages like Ruby.

Docco

Docco provides “narrative” style documentation that reads more like a manual than your typical API reference. It turns your comments into documentation on one side of the page, with the actual code on the other side. CM1.js uses Docco to great effect.

HTML

Having a dedicated web page for your client or API can be a big help. For example, our CM1 site, rather than being a brochure for our service, is a guide to using our API and an introduction to our language-specific API clients.

Eat your own dog food

It should go without saying, but by using your API for your own projects, you instantly become a constructive critic of your own work. The great benefit is that because you own the API, you get to change it if you don’t like it! This is particularly useful in early stages of API development.

Use VCR or other HTTP mocking libraries

VCR is a great testing tool that fakes out HTTP requests so that your tests run quickly and are run against real responses. A nice feature of VCR is that you can configure it to refresh response data, say, every month so you can verify that your client still works with your latest API.

Here’s an example from the carbon gem:

describe Carbon do
      describe '.query' do
        it "calculates flight impact" do
          VCR.use_cassette 'LAX->SFO flight', :record => :once do
            result = Carbon.query('Flight', {
              :origin_airport => 'LAX', :destination_airport => 'SFO'
            })
            result.decisions.carbon.object.value.should be_within(50).of(200)
          end
        end
      end
    end

In JavaScript land, a tool called replay provides similar functionality.

Do the multithreading for them

It’s best to save developers the trouble of handling performance issues by providing a solution. This goes hand-in-hand with eating your own dog food. We took our own pattern of parallelizing CM1 requests and baked it into the carbon gem. Simply pass Carbon.query an array of calculations to perform, and we’ll use the amazing Celluloid gem to parallelize the requests. Celluloid provides a pool of threaded workers for this task.

The carbon gem first creates a Celluloid worker pool:

require 'celluloid'

    module Carbon
      class QueryPool
        include Celluloid

        def perform(query)
          query.result
        end
      end
    end

Then it hands out each query to workers in the pool:

queries.each do |query|
      pool.perform! query
    end

This is a super-simple way to provide parallelism to your API users.

Make it asynchronous

An interesting trend among API providers has been the idea of providing a queued interface. This makes asynchronous processing much easier for developers and also takes some load off of your web servers. We even played around with an SQS-based client at one time with our carbon gem. In the future, we could see a Socket.IO-based, asynchronous API for our JavaScript client.

Writing XLSX from Ruby

2012-06-12T00:00:00+00:00

Our xlsx_writer library for Ruby lets you create spreadsheets compatible with Microsoft Office 2007 Excel and above.

Features

Essential cell types: general, currency, date, integer, float (decimal)
Standardized formatting: Arial 10pt, left-aligned text and dates, right-aligned numbers and currency
Auto-fit to contents: always enabled
Autofilters: just give it a range of cells
Header and footer print styles: margins, arbitrary text, page numbers, and vector logos (.emf)

Basic example

require 'xlsx_writer'
doc = XlsxWriter::Document.new
sheet1 = doc.add_sheet 'Sheet1'
sheet1.add_row ['header1', 'header2', 'header3']
sheet1.add_row ['a', 'b', 'c']
sheet1.add_row [1, 2, 3]
require 'fileutils'
FileUtils.mv doc.path, "/path/to/desired/location"
doc.cleanup

Advanced example

require 'xlsx_writer'
doc = XlsxWriter::Document.new
sheet1 = doc.add_sheet("People")

# First add data...

sheet1.add_row([
  "DoB",
  "Name",
  "Occupation",
  "Salary",
  "Citations",
  "Average citations per paper"
])
sheet1.add_row([
  Date.parse("July 31, 1912"), 
  "Milton Friedman",
  "Economist / Statistician",
  {:type => :Currency, :value => 10_000},
  500_000,
  0.31
])

# Then add autofilters and page styles...

sheet1.add_autofilter 'A1:E1'

# (figure out your croptop and cropleft by mocking it up in Excel and then unzipping the xlsx file. Get the .emf files, "cropleft" (if necessary), etc. from there)

left_header_image = doc.add_image('image1.emf', 118, 107)
left_header_image.croptop = '11025f'
left_header_image.cropleft = '9997f'
center_footer_image = doc.add_image('image2.emf', 116, 36)

doc.page_setup.top = 1.5
doc.page_setup.header = 0
doc.page_setup.footer = 0
doc.header.right.contents = 'Corporate Reporting'
doc.footer.left.contents = 'Confidential'
doc.footer.right.contents = :page_x_of_y
doc.header.left.contents = left_header_image
doc.footer.center.contents = [ 'Powered by ', center_footer_image ]

# Finally you can generate the file.

require 'fileutils'
FileUtils.mv doc.path, 'myfile.xlsx'

# don't forget
doc.cleanup

Debugging utilities

The library comes with two scripts:

unpack.rb: Takes an XLSX file, unzips it, and reformats the XML it contains to be more readable.
repack.rb: Takes a directory, converts the XML files to DOS line endings, and zips it into out.xlsx.

They have been useful in the past for debugging Excel crashes. You create a file in xlsx_writer and also in Excel, then unpack both of them and do a line-by-line comparison of the XML files within using diff -r.

Vote for Sparkwire!

2012-05-17T00:00:00+00:00

We want YOU to vote for Sparkwire, our Apps for Energy challenge entry. It allows any app to access your Green Button data without you having to download it yourself from your utility.

Green what?

Green Button is a new standard being led by the Department of Energy which allows anyone to download their energy usage data from their utility. The DOE started the Apps for Energy contest in April to help drive use of the new standard. Currently, 15 utilities serving 27 million homes have committed to providing Green Button downloads. With this data, there are many ways apps could help us save energy: think targeted conservation tips to comparisons with neighbors to verification of energy-efficiency investments to rewarding greener behavior. Many companies and individuals have already developed great new energy apps to help all of us make sense of this data, reduce our energy use, and save money.

There is a catch, though: for these energy apps to work well, they have to be able to get our Green Button data without us having to log in and download the data every month/hour/minute. Our experience in helping individuals reduce their environmental impact has taught us that removing barriers to entry is critical. So we created our own app, Sparkwire, to easily share your Green Button data with other apps. You just provide Sparkwire with your utility site login and it does the rest. Any app connected to Sparkwire can pull in your latest data without any additional log-in or download. Don’t worry, your login info is encrypted and can only be used when an app you authorize requests access. This video demonstrates everything.

Please give us your support by voting today (and every day thereafter :)) at challenge.gov.

2012 Fuel Economy Data

2012-05-17T00:00:00+00:00

Another data update - you can now find the fuel economy and other info for all 2012 model-year automobiles sold in the US in our public data repository.

This data release took unusually long to process because we decided to improve the way we handle dual-fuel and alternate fuel vehicles in light of their increasing popularity. We now store all EPA-reported fuel efficiencies for every vehicle. Using the Automobile or Automobile Trip impact models on Cm1 you can specify a particular fuel with the ‘automobile fuel’ characteristic.

Electric Utility Data

2012-05-14T00:00:00+00:00

We’ve just added US electric utilities to our public data repository. Our current data includes which zip codes each utility serves (from the EIA) and whether the utility has committed to or already begun giving customers access to their own energy information through the Green Button program.

EcoHackNYC, spring 2012 edition

2012-04-29T00:00:00+00:00

Last weekend we were proud to sponsor another round of the fantastic EcoHackNYC green hackathon event.

{.wide}

It’s always amazing to see another crop of apps for the environment emerge over the course of just one day. Personally, I worked with a team on CSA Builder, a tool for local food organizations to figure out where to establish CSA pick-up locations for maximum effect.

Look forward to next time!

A new perspective on hotel sustainability

2012-04-26T00:00:00+00:00

We have released the results of our latest research, focused on assessing the efficiency of 46,000 individual US hotels. The report, Hotel Carbon & Energy Efficiency, presents efficiency rankings for 75 of the largest hotel chains, examines key drivers of efficiency, and analyzes industry trends.

The analysis was performed using our CM1-based hotel impact model to estimate footprints for each individual hotel property, based on building characteristics data from the Northstar Travel Media hotels database. The model uses factors like a hotel’s location, size, number of floors, climate, construction date, and amenities like fridges and pools to predict energy use and carbon emissions using fuzzy set analysis that references the US EIA’s Commercial Buildings Energy Consumption Survey.

A few key findings include:

Hotel impact per room-night varies more than tenfold across the lodging industry. The most efficient quarter of hotels use just 7% of the industry’s energy, while the dirtiest quarter consume more than 50%.
Footprint reduction opportunities exist for hotel customers at every price point. Major footprint variation exists within service classes and even between hotels of the same chain in the same city, making it possible for most travelers to reduce their impact without increasing cost or limiting travel.
Hotels are growing less and less efficient. Energy and emissions per room-night have doubled over the past 50 years, driven by increasing area per room, increasing amenities, and increasing reliance on dirty fuels.
Hotel chains vary enormously in their impacts. Our analysis ranked Vagabond Inns as the most efficient among 75 of the largest hotel chains, while JW Marriott had the greatest estimated impact per room-night.

Write code, save the planet

2012-04-25T00:00:00+00:00

We’re happy to announce greendreams, a compendium of environmental APIs for all the Cleanweb hackers out there.

{.wide}

Currently we have 6 APIs listed, but of course the more the merrier, so please fork away and add your favorites. Big thanks go out to Genability, GoodGuide, NREL, EPA, and AMEE for helping out with the first crop of APIs.

Introducing Prospect

2012-04-23T00:00:00+00:00

Have you ever wanted to add environmental impact data to your site? You’ve probably been too busy or don’t have the resources to have a developer integrate your site with an API like CM1. If so, we have good news for you! With our new service, Prospect, you can add the power of CM1 (carbon footprints, resource usage, etc.) to your website with a minimal amount of coding! If you can edit HTML on a web page, you can be up and running with Prospect in minutes.

{.wrapped} For example, let’s say you have an automobile sales site and you’d like to show your buyers what the yearly greenhouse gas emissions or fuel usage would be for each car on the page. Simply tell Prospect which HTML elements (using CSS rules) on the page provide input data that can be fed to our automobile CM1 model, insert a special <script> tag on your page, and the environmental impacts will appear on your page. No need to hire a developer to integrate with CM1. Now your in-house web master or power-user can do it all.

An example of Prospect in action is at http://prospect.brighterplanet.com/otto-s-autos. Reload and notice how the footprints magically appear at the bottom of each car description. The only change needed on that page was to add a <script> tag at the top.

With Prospect we hope even more sites will be able to integrate environmental impact measurements and help all of us make greener decisions.

Prius vs. Volt Reprise

2012-04-17T00:00:00+00:00

Following the surge in sales of the Chevy Volt in March, we thought it could be interesting to revisit our post from August 2009 comparing the greenhouse gas emissions of the Volt to the Toyota Prius.

Sneak peak: the Prius still rules in most of the US.

The EPA rates the 2012 Chevy Volt at 97 miles per gallon equivalent (36 kilowatt hours per 100 miles) when running on electricity alone, or 60 miles per gallon for a combination of electric- and gasoline-powered driving. That handily beats the 2012 Toyota Prius’ 50 miles per gallon. And yet the Prius is still the greener option for two thirds of Americans.

How can this be? When running on electricity the Volt doesn’t eliminate emissions, it just shifts them from its tailpipe to a power plant smokestack. And throughout much of the country electricity is more than twice as dirty as gasoline. This map shows where, based on the dirtiness of the power grid, it’s still better to drive a Prius. We’ve assumed the Volt operates in electric-only mode - the Prius would dominate even more if we compared mixed-mode driving.

Based on eGRID2010 v1.1 subregion emission factors

Our goal here isn’t to denigrate the Volt or plug-in hybrids in general. On the contrary we’re excited to see these vehicles entering the mainstream. In the long run electric cars will be cleaner than the most efficient hybrid imaginable, and they’re already the greener choice for anyone who generates their own power from renewable sources or has access to relatively clean grid electricity. Rather we want to emphasize the importance of shifting to cleaner electricity sources in tandem with our transition to efficient electric vehicles. Until we do, so-called “zero emissions vehicles” will remain anything but.

N.B.

To simplify the comparison, we’ve assumed that the emissions from manufacturing the Volt and Prius are equivalent and that the vehicles have similar lifetimes. We’ve also left out emissions from extracting, transporting, and processing raw fuels into electricity and gasoline. A rough comparison using Carnegie Mellon’s lifecycle assessment tool and EIA energy prices suggests that the embodied emissions of electricity are greater than those of gasoline, so including these would skew things even farther in the Prius’ favor.

How to install mosh on Amazon EC2

2012-04-14T00:00:00+00:00

Here’s how to install mosh on Amazon EC2 instances:

Using EPEL

Thanks to @masnick’s instructions on the mosh wiki:

Enable the EPEL repository.
sudo yum install protobuf-compiler protobuf-devel libutempter-devel ncurses ncurses-devel zlib-devel boost-devel
Download the latest release from http://mosh.mit.edu, unzip, and ./configure, make, sudo make install.

Without EPEL

You have to install protobuf-compiler and protobuf-devel manually. Most of the rest is the same.

$ sudo yum install git-core boost-devel libutempter-devel ncurses-devel zlib-devel perl-CPAN cpp make automake gcc-c++
$ sudo cpan IO::Pty
  [say yes twice]
$ curl -O "http://protobuf.googlecode.com/files/protobuf-2.4.1.tar.gz"
$ tar -xzf protobuf-2.4.1.tar.gz 
$ cd protobuf-2.4.1
~/protobuf-2.4.1$ ./configure 
~/protobuf-2.4.1$ make
~/protobuf-2.4.1$ sudo make install
~/protobuf-2.4.1$ sudo echo "/usr/local/lib" > /etc/ld.so.conf.d/usr_local_lib.conf
~/protobuf-2.4.1$ sudo ldconfig | grep proto
  [you should see libprotobuf, etc.]
~/protobuf-2.4.1$ cd
$ git clone https://github.com/keithw/mosh
$ cd mosh
~/mosh$ ./autogen.sh 
~/mosh$ ./configure PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
~/mosh$ make
~/mosh$ sudo make install

Here’s something that’s easy to copy-paste:

sudo yum install git-core boost-devel libutempter-devel ncurses-devel zlib-devel perl-CPAN cpp make automake gcc-c++
sudo cpan IO::Pty
  [say yes twice]
curl -O "http://protobuf.googlecode.com/files/protobuf-2.4.1.tar.gz"
tar -xzf protobuf-2.4.1.tar.gz 
cd protobuf-2.4.1
./configure 
make
sudo make install
sudo echo "/usr/local/lib" > /etc/ld.so.conf.d/usr_local_lib.conf
sudo ldconfig | grep proto
  [you should see libprotobuf, etc.]
cd
git clone https://github.com/keithw/mosh
cd mosh
./autogen.sh 
./configure PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
make
sudo make install

See the full log here.

Then you need to open the EC2 port: (note UDP)

New flight data from ICAO

2012-04-02T00:00:00+00:00

We’ve just incorporated the latest ICAO flight stage data into our flight carbon and energy model. The update includes data for international flights in 2009, 2010, and 2011 and adds several new airlines, such as Air Bucharest, Mihin Lanka, and UTair-Ukraine. It also adds some new direct routes such as Accra to Algier, Malaga to Moscow, and Zurich to Yerevan.

Will premium gasoline improve your fuel economy?

2012-03-14T00:00:00+00:00

This morning’s NPR marketplace included a list of money-saving tips for drivers. Most are spot-on, but one surprised me: the recommendation that everyone use 91 octane premium gasoline.

Numerous sources including the Federal Trade Commission, Scientific American, and the California Energy Commission have debunked the myth that a higher octane rating will give you a performance boost or keep your engine cleaner. Possibly alluding to this, the tip claims that premium gasoline is better “because it’s more filtered, not because of the octane.”

Since all grades of gasoline have the same energy content I’m skeptical that any slight difference in purity could make up for a roughly 7% price premium.

My take: follow the other tips but stick with regular unleaded.

300,000,000 pounds

2012-03-13T00:00:00+00:00

I’m getting word that Brighter Planet credit and debit cardholders have collectively blazed past yet another major milestone on the road to a cleaner future: 300,000,000 pounds of carbon dioxide emissions offset!

Three hundred million pounds. Sounds impressive, but how much prevented CO₂ is this, really? Well, it’s equivalent to the carbon footprint of all the lights in every US home over more than four days – or of more than eleven million Americans leaving their car in the garage for a day and instead riding their bicycle to work. This volume of CO₂ would fill a few party balloons for every child on earth – or it would fill one tractor trailer, every single day, for 1800 years.

An impressive accomplishment indeed. But what’s equally impressive is how it’s been accomplished: through the widespread use of innovative technology and market mechanisms that harness the power of everyday actions to build (quite literally) a clean energy future.

Thank you, all you Brighter Planet members, for doing your part.

State electricity emission factors from eGRID

2012-03-05T00:00:00+00:00

Last week I was trying to calculate the greenhouse gas emissions for each building in the EIA Commercial Building Energy Consumption Survey (CBECS) microdata. Fuel oil and natural gas emissions were easy enough, but electricity emissions posed a problem.

The standard way to calculate electricity emissions in the US is to use EPA eGRID emission factors. To do this I needed to know the eGRID subregion each building was in. Usually I’d use data from the EPA power profiler tool to look up the eGRID subregion for each building’s zip code. But to ensure anonymity CBECS doesn’t report a building’s zip code or even state, just its census division.

My solution was to add population data to most zip codes using ZCTA data from the 2010 Census. I then calculated the average electricity emission factor across all zip codes in a census division, weighted by population.

Weighting by population amounts to assuming that the probability of the building being in a particular zip code is proportional to the zip code’s population. For this particular application it’d be better to weight by the number of commercial buildings in each zip code, but population should be a reasonable indicator of this.

While I was at it I calculated population-weighted average electricity emission factors for each state and added this data to our states table. These emission factors are a good alternative if you know the state but not the exact eGRID subregion for electricity use. Ideally I’d weight the zip codes by total electricity consumption, but that data simply isn’t available.

Inferential modeling - fuzzy sets vs. cohorts

2012-03-01T00:00:00+00:00

Inferential modeling is a big part of our R&D at Brighter Planet. Our impact models are designed to estimate the energy use of some activity without necessarily knowing all the variables that directly drive energy use.

For example, let’s say we want to model the energy use of a modest weekend at the Bellagio in Vegas. We know some information like the local climate and building size, but we don’t know the Bellagio’s exact energy demand. What’s the best way to estimate it?

Basic idea: look at similar properties

A technique we often use in this kind of situation is to cross-reference the information we have with a dataset that includes energy use – in this case the US EIA Commercial Buildings Energy Consumption Survey (CBECS). We find the CBECS records that represent hotels similar to the Bellagio and calculate their average energy intensity.

But what’s ‘similar’?

The big question is how to identify which CBECS records are similar enough to the Bellagio to merit inclusion in our average. There are two basic methods we’ve employed.

Cohorts

The cohort approach is clean and simple. Using the cohort_analysis gem we filter out all CBECS hotel records that don’t match the Bellagio on key variables. If we’re left with fewer records than a pre-defined minimum sample size we drop the least important variable and re-filter until we have enough records. We then calculate the average energy intensity of those records.

Fuzzy sets

The fuzzy set approach is more nuanced. It recognizes that for continuous variables or when there’s more than one variable a CBECS hotel record isn’t an all-or-nothing match, but rather varies in its degree of similarity. Using the fuzzy_infer gem we assign each record a score for each variable based on how closely it matches the Bellagio. We compile the scores into a “fuzzy weight” and then calculate the average energy intensity across all the records, weighted by their fuzzy weight.

But which is better?

Both approaches follow the same basic profiling idea, but the cohort method is intuitive and faster while the fuzzy set method requires more computation and a lot of statistical tinkering to set up. So is the fuzzy set method really worth all the extra trouble?

We ran some tests, and the answer is definitive.

Fuzzy sets are significantly more accurate

	Cohort	Fuzzy Set
Average variation from actual	68%	50%
Median variation from actual	43%	33%
Correlation with actual	0.29	0.76

Beware of String#hash being used for cache keys...

2012-02-29T00:00:00+00:00

Every process will have a different hash value for the same string, so cache keys based on String#hash will not work as expected!

1.9.3-p0 :001 > 'test'.hash
 => 240227015057187339 
1.9.3-p0 :002 > 'test'.hash
 => 240227015057187339

But in another IRB session:

1.9.3-p0 :001 > 'test'.hash
 => -2779337368972820904 
1.9.3-p0 :002 > 'test'.hash
 => -2779337368972820904

All calls to plain vanilla Object#hash have the same problem. It turns out it’s intentional…

… as explained by Yui Naruse:

It is intended. Ruby 1.9 explicitly use session local random seed to calculate a hash for strings (and some other objects).

… just not mentioned in the core Ruby docs for String#hash, which say:

Return a hash based on the string’s length and content.

There is a 7-month old pull request from FND to fix the docs… let’s hope it gets merged soon to prevent further confusion!

Meet our turbocharged lodging model

2012-02-23T00:00:00+00:00

We’ve just rolled out the latest version of our hotel energy and emissions model, and it includes a number of new advancements that make lodging sustainability quantification more accurate, broadly applicable, and useful than ever before.

Corporate travel is a fast-growing focus for sustainability managers, and we’re excited about the opportunities these new capabilities will give CM1 clients to empower smarter decision-making in this area.

This latest version includes four major upgrades:

Integration of the massive Northstar hotel database. Ian previously posted about our acquisition of this huge and detailed international hotel properties data set. Today’s update integrates this data into the lodging model, letting users model energy use and GHG emissions for stays at tens of thousands of specific hotels around the world – tourism and business travel applications can now compute sustainability data based on building information from the actual hotels on their itineraries.
Improved climate data. Local climate is a key predictor of the energy efficiency of a hotel room, as it drives heating and air conditioning needs. This release adds nuance to the climatic portion of the model using climate normals data from World Resources Institute’s (WRI) CAIT database.
New CBECS fuzzy set analysis. Commercial Buildings Energy Consumption Survey (CBECS) data from the US EIA has long been central to the lodging model, but we’re now using more advanced big data analysis techniques to make powerful estimates of hotel energy consumption based on factors like a hotel’s construction year, size, and climate control infrastructure.
Amenities-based differentiation. The broad brushstrokes of climate and building infrastructure are key in painting the picture of a hotel’s energy use, but so too are details about specific energy-using appliances. The lodging model now takes information on amenities like fridges, minibars, hot tubs, and swimming pools into account, helping provide even sharper contrast among seemingly similar hotel options.

You can test drive the lodging model via our query builder or our API.

Keystone: "XL" is pretty apt

2012-02-13T00:00:00+00:00

We’re in the midst of 24 Hours to Stop Keystone XL, a day-long push by 35+ organizations to send half a million letters to Senators asking them to stop the pipeline. It’s a worthy, urgent cause and we at Brighter Planet will all be sending our letters today.

Naturally we were tinkering with some of the numbers related to Keystone, and one question jumped out at us: Just how much CO2 emissions are represented by the oil in KXL at any given point in time?

To get an answer we used CM1’s Fuel Purchase impact model, feeding in the total volume of the pipeline extensions¹, along with the type of oil (in this case, crude). The result:

2.4 million tons CO2e

That’s the GHG emissions represented by the oil that would be inside KXL at any point in time. Here’s the methodology.

“XL” is right.

Wikipedia tells us the radius and length of the two extensions that make up the “XL” part of Keystone. We plugged that into Wolfram Alpha to get the volume. ↩

New wind offset project

2012-01-30T00:00:00+00:00

Time for a new offset project - this time it’s wind turbines on two family farms in northern Iowa.

Image credit: NativeEnergy

Once again we’re working with our partner NativeEnergy to support a small project that fights climate change and strengthens the local community. The project’s emissions reductions will be validated and verified under the Verified Carbon Standard.

This latest project involves two 1.6 MW turbines, one on Ruth and Ken Benjegerdes farm, the other on Lesley and Nora Mammen’s. Both families have watched as wind turbines transform this mostly coal-powered landscape, bringing jobs, increased tax revenue, and rural economic development. Young people who used to leave the towns have begun to stay, and farmers are welcoming a new source of critical income.

Lesley Mammen was born in Iowa, although he left for several years before returning home. He and his wife, Nora, can see a large wind farm from their property, which inspired them to investigate wind on their own land.

Ken Benjegerdes is the grandson of the original homesteaders, and his family has owned the land for nearly 100 years. From the porch of the house in which he was born, Ken and Ruth can now look over their fields of soybeans and corn to watch their own turbine produce renewable energy.

As always, we’re proud to help our customers and cardholders build a clean energy future.

Cleanweb Hackathon NYC

2012-01-27T00:00:00+00:00

We’re back from the Cleanweb Hackathon! It was a great weekend of meeting entrepreneurs in the clean tech space, joining forces with some of New York’s finest hackers, and hanging out at NYU’s Interactive Telecommunications space.

Image credit: @greenskeptic, Instagram

Hacking

Andy, Seamus and I helped two teams write apps and help get others up and running with our CM1 API and public data.

I helped prototype an app, CleanGPA, which gives you a GPA-like score based on your home energy usage. We developed with Rails, and aside from a few hangups around OAuth, I was once again amazed at how fast you can build an app with tools like devise, formtastic. I’ve also been thrilled with the ease and speed of using faraday and vcr as tools to build clients against RESTful APIs.

Yoga & Juice

We also had the pleasure of sponsoring an hour-long yoga session. It was intense but energized me for the rest of the day. My abs are still a little sore!

After yoga, we enjoyed some cleansing juices from Liquiteria. I am a huge fan of ginger and these drinks really hit the spot.

The Apps

The winning apps were Econofy, an efficient appliance shopping guide and, NYCBldgs, a tool that highlights the best and worst-performing buildings in New York City. Econofy did a great job rating products on a five-point scale and helping to calculate money saved by projecting electricity costs. NYCBldgs put New York’s public building energy usage data to good use. I was amazed that the city was opening up so much useful data like this. It really goes a long way in helping us “clean tech hackers” get the job done.

The top 3 things I saw at the Detroit Auto Show

2012-01-25T00:00:00+00:00

One of the benefits of living in Michigan is getting to swing over to the North American International Auto Show in Detroit. Here are the most interesting sustainability themes I noticed this year.

More electric

Nearly every auto maker offers some sort of hybrid, electric, or diesel-powered car. It seems like not very long ago there were only a few companies offering hybrids and many alternative fuel cars were merely concepts. Even Dodge, not normally known for fuel efficiency, boasted of the new Dart offering improved fuel economy with its turbocharged engine.

I am a geek and one of the neat parts about the auto show is the way the auto makers display their technology. A few companies displayed the inner workings of their electric drivetrains and batteries. It’s very eye-opening to see how many batteries they can stuff into the cars and how may batteries are required just to propel a 2,000lb car at speeds we’re accustomed to. It was also fun to listen to visitors from the auto industry examine and critique the construction of the Tesla drivetrain. It reminded me of all the time I’ve spent evaluating and choosing open source software projects on Github.

Alternative fuels for fleets

A company called VIA really intrigued me. They convert GM trucks and vans into electric vehicles that operate similarly to the Volt. A unique benefit of essentially converting a utility truck into a mobile generator is that you can plug any of your electric tools into an outlet connected to the engine. This sort of conversion could really benefit companies looking to reduce emissions and/or save on fuel costs. Since these are OEM conversions, they will appear in next year’s EPA fuel economy guide, which means they’ll show up in our database, too!

Car alternatives

With all of the improved gas-burning cars and flashy new (and expensive) “battery-guzzling” electric cars, I was surprised to see something you’d never expect to see at an auto show - bicycles, scooters, and personal rapid transit cabs. Since these smaller vehicles only need a battery a tenth of the size of an electric car (or smaller), these could end up being a more practical solution for many.

Overall, smaller, more efficient vehicles are here in force. There were still plenty of powerful, sporty cars and trucks, but even these are seeing efficiency improvements. For everyday driving, though, better efficiency is a win for the environment - as long as we also reduce or maintain overall vehicle miles traveled.

New data from Northstar Travel Media

2012-01-23T00:00:00+00:00

We’re close to finishing some exciting updates to our Lodging model: soon it will be able to identify the actual hotel a client stayed at and use that property’s physical characteristics to calculate energy use and emissions.

A key piece in this process is the hotel database we just purchased from Northstar Travel Media.

Northstar’s database covers more than 200,000 hotels worldwide. Along with a unique identifier for each property, it includes locational information and building attributes such as when the hotel was built, when it was last renovated, and how many rooms it has. It also provides some important energy use indicators like how many rooms are air-conditioned.

With this new data we’ll be able to fine-tune our energy and emission predictions to reflect the actual characteristics of the hotel where a lodging occurred, rather than relying on broader averages. This is particularly exciting because it will let us start to show differences in emissions between hotels in the same city.

Join us at Cleanweb Hackathon NYC this weekend

2012-01-19T00:00:00+00:00

We’re psyched to be sponsoring—and participating in—this weekend’s Cleanweb Hackathon in New York City.

{.wide}

As usual, we’ll be holding a series of Healthy Hacker activities over the course of the weekend. (Above is a shot of the Healthy Hacker yoga class we held during EcoHackNYC in November.)

{.wrapped} Brian Nygard, a YTTP instructor, will be leading a yoga session for attendees at 2pm on Saturday. If you want a spot, make sure to put your name on the list first thing in the morning, as space will be limited.

{.wrapped} At 3pm we’re going to have fresh cold-pressed detox juices delivered by NYC’s famous Liquiteria.

If you haven’t signed up for the Hackathon, all the more reason to sign up now!

Fuzzy match in Ruby

2012-01-18T00:00:00+00:00

Our fuzzy_match library for Ruby can help link (cross-reference) records across data sources—for example, match up aircraft records from the Bureau of Transportation Statistics and the Federal Aviation Administration:

90% of the way by default

Let’s look at only the Boeing 737 records for now…

bts_records = [
  'Boeing 737-800', 'Boeing 737-5/600lr', 'Boeing 737-500',
  'Boeing 737-400', 'Boeing 737-300lr', 'Boeing 737-300',
  'Boeing 737-100/200', 'Boeing 737-200c'
]
faa_records = [
  '737-100', '737-200, Surveiller (CT-43, VC-96)',
  '737-300', '737-400', '737-500', '737-600',
  '737-700, BBJ, C-40', '737-800, BBJ2', '737-900',
  '737 Stage 3 (US ONLY)',
]
require 'fuzzy_match'
puts [ 'BTS'.ljust(24), 'FAA' ].join    # print a nice table header
matcher = FuzzyMatch.new(faa_records)   # set up a matcher object
bts_records.each do |bts|
  faa = matcher.find(bts)               # given BTS record as input, find a matching FAA record
  puts [ bts.ljust(24), faa ].join      # print a row showing the match
end

which produces

$ ruby example.rb
BTS                     FAA
Boeing 737-800          737-800, BBJ2
Boeing 737-5/600lr      737-600
Boeing 737-500          737-500
Boeing 737-400          737-400
Boeing 737-300lr        737-300
Boeing 737-300          737-300
Boeing 737-100/200      737-100
Boeing 737-200c         737-100  # <- oops!

Add rules to get to 95%

Fuzzy matching may catch 90% by itself, but you will have to define rules to get to 95%.

In this case, the error is “Boeing 737-200c” matching “737-100”. Let’s use an “identity” rule for “7X7-XXX”…

identities = [
  %r{(7\d7)-?(\d\d\d)} # when comparing two records that both contain 7X7, make sure all the digits (but not the dash) are equal
]
matcher = FuzzyMatch.new(faa_records, :identities => identities)

which produces the correct match

Boeing 737-200c         737-200, Surveiller (CT-43, VC-96)

Rules and options

Check out the fuzzy_match documentation for all the kinds of rules…

:blockings
:normalizers
:identities
:stop_words

and also options you can pass to find…

:read
:must_match_blocking
:must_match_at_least_one_word
:first_blocking_decides

That’s it!

Why the Brighter Planet API uses POST

2012-01-16T00:00:00+00:00

Have we really created a RESTful web service? If so, why are we specifying that users send POST requests to get calculations? I asked this question to the rest of my team and a lively debate ensued among us.

Under the REST convention we use GET requests to retrieve data that represents some entity pointed to by a URI. We use POST to create a new entity on the server.

When a CM1 user POSTs a calculation request to our service, e.g. POSTing “airline=Delta” to http://brighterplanet.com/flights.json, a flight calculation isn’t actually stored on our server. Instead, a calculation is run against the data that exists in our database. Why then do we use the POST verb if no resource is actually created?

To answer this question, W3C has a handy guide for determining which verbs are appropriate in different situations:

1.3 Quick Checklist for Choosing HTTP GET or POST

Use GET if:
  * The interaction is more like a question (i.e., it
    is a safe operation such as a query, read operation,
    or lookup).
Use POST if:
  * The interaction is more like an order, or
  * The interaction changes the state of the
    resource in a way that the user would perceive
    (e.g., a subscription to a service), or
  * The user be held accountable for the results
    of the interaction.

However, before the final decision to use HTTP GET
or POST, please also consider considerations for
sensitive data and practical considerations.

In our case, we have two reasons to use POST: 1. The calculation request results in the user being billed for usage – “the user is held accountable” for the results. 1. The request contains sensitive information – the user’s API key – which should not be included in a link to a calcuation. That is, a GET URL should double as a hyperlink reference, but we don’t want the API key to be revealed (as in http://impact.brighterplanet.com/flights.json?key=ABC123.) Every calculation result includes a GET-able methodology link that doesn’t include the API key, so you can safely share the link once the calculation is made.

Sustainability trends to watch

2011-12-21T00:00:00+00:00

We’ve just posted a brief report on our research page with the top five sustainability trends we’re watching out for in 2012. From new pressures to new areas of focus to new management techniques, we think the next year is gearing up to be a big one for the sustainability aroud the world. What would you add to our list?

285 million pounds and counting

2011-12-21T00:00:00+00:00

As of today, Brighter Planet’s cardholders have offset more than 285,000,000 pounds of carbon dioxide emissions. By simply using your Brighter Planet credit and debit cards in your daily lives, you’ve helped fund 20 renewable energy and sustainable forestry projects, bringing green jobs to rural America, proving the viability of community-scale clean technologies, and preventing nearly two weeks worth of GHG, SO₂, mercury, and particulate pollution from a typical coal-fired power plant.

The CO₂ you’ve collectively prevented is equivalent to:

Every home in the US shutting off all its lights for more than 4 days
The emissions sequestered by 33 million tree saplings in a year
More than 10 million people biking to work for a day instead of driving
Each cardholder powering their home with renewable energy for 3 weeks
Grounding all air travel to and from NYC for more than 5 days

Keep up the good work!

Building snowflakes: the tech behind our holiday card

2011-12-19T00:00:00+00:00

Last week we posted our 2011 holiday card, which has seen quite a bit of traffic since. There’s actually some pretty interesting new technology under the hood, so I thought I’d put together this behind-the-scenes blog post for anybody who’s interested.

When designing the card, I knew that I wanted to use a kind of real time animation to express the diverse flow of calculations that CM1 is performing at any given time. Until recently “real time” on the client side meant polling, but the recent introduction of WebSockets has changed all that.

Ultimately I decided to use Pusher, an incredible service that abstracts away a lot of the messiness of using WebSockets in a “pubsub” architecture. Implementing Pusher on the server side meant adding this single line to the right place in CM1’s codebase:

::Pusher['queries'].trigger!('announce', billed_query.slice('emitter', 'carbon_value'))

What this does: every time a calculation is made on CM1, the “queries” channel within the “CM1” app of our Pusher account receives an “announce” notification including two details from the query (the name of the impact model and its footprint).

On the client side, the app sets up every browser to act as a “subscriber” to this channel with these three lines in index.html:

pusher = new Pusher('4441a27a742385492eb3'); // that's our public Pusher key
queries = pusher.subscribe('queries');
queries.bind('announce', displayQuery)

Now, every time a query is performed on CM1, Pusher gets a notification, and this kicks off notifications to all of the browsers currently looking at the card, each of which execute the displayQuery function with the impact model’s name and footprint as parameters.

OK, now we now how the card gets the details to display as snowflakes, but how do we draw the actual snowflakes themselves?

For this we use HTML5’s Canvas element for dynamic drawing and animation. In truth, most of the messy animation stuff is handled by the excellent Three.js library; the appearance and motion of the snow was inspired by a post from Seb Lee-Delisle. I just made a few visual modifications and wired it all up to the notifications coming in from Pusher.

So, there you have it. Happy to clarify things or answer questions in the comments. Happy holidays!

Let it snow!

2011-12-16T00:00:00+00:00

Every year we do a holiday card for our friends (remember last year’s?) that connects the work we do to some aspect of the season. Click the image to check out this year’s card:

There’s some fancy new technology under the hood (more on that ~~in a later blog post~~ here), so you’ll need a new-ish browser.

Wishing you all the best in 2012, Patti and the team

Three big trends in employee sustainability engagement

2011-12-06T00:00:00+00:00

Two years ago we reported the results of our first survey on employee sustainability engagement, to a surprising amount of interest from non-profits, businesses, and governments. Today we’re releasing our second biennial survey results on the subject, updating the picture of engagement initiatives, digging deeper into best practices for effective programs, and analyzing trends in this fast-evolving space.

We heard from nearly 1000 respondents in 47 states and 51 countries, including employees at WalMart, Visa, UPS, Coca-Cola, Exxon, McDonalds, the US Government, and many other leading organizations. Three things that surprised us from this year’s findings that folks working on green engagement initiatives should keep in mind include:

It’s not all rosy. Green engagement programs are becoming less effective as they spread. Employers are promoting staff conservation at higher rates than in 2009, but the number of programs rated as “very effective” or “somewhat effective” at actually eliciting green employee actions dropped notably. Are program leaders failing to heed best practices established at the most successful organizations, or are new programs simply slow on the uptake? Either way, it suggests the possibility that employee weariness at ineffective sustainability initiatives could undermine promising progress in this space if it’s not taken seriously.
Breadth is key. A defining characteristic of the most effective programs (compared to those that promote sustainability frequently but have low effectiveness) is that they focus more in emerging green issues like procurement, water use, and business travel. Interestingly, they’re no more likely to promote traditional sustainability issues like recycling, energy use, and commuting than their less successful counterparts. Expanding beyond these basic issues signals forward thinking and perhaps a more genuine environmental commitment – characteristics that are more likely to inspire employee action.
Data is power. Organizations that collect data on their footprint, the impact of staff travel and commuting, and employee sustainability efforts were roughly three times as likely to have a very effective program. And this group is growing, with the number of employers collecting these data increasing 15% since 2009, to three in ten.

The full report is available for free download on our research page.

We’d also like to thank Conservation International’s Business & Sustainability Council for helping to get the word out about the survey.

Building queries for fun and profit

2011-11-18T00:00:00+00:00

The primary way to experiment with CM1 is to hit the API directly—either with code, a tool like cURL, or with our CM1 console. But sometimes it’s just easier to play around in a browser, so today we’re rolling out a Query Builder feature for each of our impact models. Details after the jump.

To get started, visit the details page for any of our impact models—you’ll find the model’s query builder at the bottom of its page.

On the left is where you build your request by adding, defining, and tweaking characteristics according to the model’s API (click the “characteristics API” link on that same page for full details).

As you type, the query builder will continuously submit your request to CM1. Interpretations of your characteristics will display below the text fields, and the carbon impact will update on the right. In the lower right you’ll find some useful representations of this query, including a human-readable methodology link and a copy-pastable cURL command.

Check out some pre-built queries by using the example dropdown in the upper-right. We’ll be adding many more example queries over the coming week.

New best practices for green data providers

2011-11-08T00:00:00+00:00

This is a time of unprecedented threat to the environment brought about by increasing population and consumption – but it’s also an age of unprecedented opportunity for innovating solutions to these challenges. Increasing migration of daily decisions and activities to cyberspace, and increasing availability of valuable data resources, are giving software developers more opportunity than ever to build data-driven apps that power more sustainable decisions. The movement to build data-driven green apps is just getting started, and the government, business, and non-profit organizations with the data to power these innovative tools have an important role to play in helping ensure their success.

That’s the focus of our latest report, entitled Growing the Green Apps Ecosystem. The paper, edited by Ethan McMahon at the EPA’s Office of Environmental Information, outlines best practices for data providers in engaging green developers and ensuring their data provision is as developer-friendly as possible. The paper combines the results of interviews we conducted with various green developers, our own experience working with data providers and green apps, and Ethan’s fact-checking perspective as an EPA official helping lead the movement for green apps innovation.

In the paper we reassess open data practices for data providers, explaining how a focus on data orientation and life cycle can help ensure that open data practices actually meet developer needs. We also outline seven tactics for engaging developers in the creation of green apps, including hackathons, APIs, contests, and data support channels. You can read the full report here.

20,000,000 calculations . . . spooky

2011-11-02T00:00:00+00:00

Sometime in the darkest hours of Halloween night, our CM1 platform processed its 20,000,000th calculation. Hurray!

But wait: after a couple days of intense analysis, we’re concluding that the Residence impact being computed was that of a bona fide haunted house. We present our argument below.

Here’s the raw request characteristics (location removed to protect the ~~innocent~~ residents):

{ :acquisition => "2008-09-01",
  :air_conditioner_use => "NOT USED AT ALL",
  :annual_coal_volume_estimate => "0.0",
  :annual_fuel_oil_volume_estimate => "0.0",
  :annual_kerosene_volume_estimate => "0.0",
  :annual_propane_volume_estimate => "0.0",
  :annual_wood_volume_estimate => "0.0",
  :clothes_drier_use => "1",
  :dishwasher_use => "4 TO 6 TIMES A WEEK",
  :floors => "1",
  :floorspace_estimate => "111.484",
  :freezer_count => "0",
  :monthly_electricity_use_estimate => "600.0",
  :occupation => "0.937",
  :ownership => "false",
  :refrigerator_count => "1",
  :residence_class => "APARTMENT BUILDING WITH 2-4 UNITS",
  :residents => "3",
  :retirement => "2009-10-07",
  :timeframe => "2011-01-01/2012-01-01",
  :urbanity => "TOWN" }

As you see, the evidence is clear. Who, besides restless spirits, never use air conditioning? And the 94% occupancy rate means the “residents” are absent 21 days per year—roughly the number of days with a full or near-full moon. Could these dear tenants be, perhaps, quietly stalking the unaware?

Sure, we can’t explain why these three poltergeist lodgers would need a refrigerator or wash so many dishes, but, after all, there’s no accounting for taste.

So there we have it, proof positive: ghosts are using CM1.

HootRoot a winner in EPA Green Apps Challenge

2011-11-01T00:00:00+00:00

HootRoot, our travel footprint mapping app, has been declared a winner in the EPA’s Apps for the Environment Challenge! Of the five awards announced in this nationwide contest for the best apps powered by EPA data, HootRoot was named the number two Best Overall App. Light Bulb Finder, a great mobile app that guides your transition away from incandescents, took first place.

Hootroot helps you navigate efficiently from point A to point B. It’s powered by Brighter Planet CM1, Google Maps, and HopStop. The app provides directions, travel times, and carbon footprints for driving, public transit, flying, and human-powered transportation options on any route. Check out video and screenshots of the app on our contest submission page.

The contest required participants to use EPA data. HootRoot relies on multiple EPA data sets to power its transportation carbon calculations: Fuel Economy Guide for car trips, eGRID for train and bus electricity emissions, and US Greenhouse Gas Inventory for fuel emissions factors across all transport modes. It’s also powered by data from Energy Information Agency, Bureau of Transportation Statistics, and other sources.

The EPA has emerged as a leader in recent years in the push for opening government data and engaging the developer community in creating apps useful to the public, and this contest is an innovative part of that strategy.

We’ll be at the EPA’s Green Apps Forum in Arlington, VA on November 8 to accept the award and participate in discussions about the future of the growing environmental apps movement. It promises to be a very engaging event, and will be streamed online if you can’t make it in person.

3 reasons to hack eco-tech at EcoHack NY

2011-10-24T00:00:00+00:00

Come at 7:30PM on November 4th to Tisch ITP's turn-of-the-century industrial loft and see if there's a project you want to hack on.
Advance the new Science Code Manifesto:
Software is a cornerstone of science. Without software, twenty-first century science would be impossible. Without better software, science cannot progress.
Share food, drinks, and yoga provided by Brighter Planet (who clearly know how to throw a party, e.g. Friday night at CodeConf 2011): (and here's the tweet to prove it)

Needless to say, we’re proud to sponsor Eco Hack NY!

Green Developers: a penny for your thoughts

2011-10-19T00:00:00+00:00

Brighter Planet is working on a paper outlining the growing ecosystem of green apps, and if you are a software developer who’s worked in this area, we want your perspective. By sharing your thoughts about your own apps and the broader movement, you’ll help inform our best practices for engaging developers and could get a bump by having your app covered as a case study in the paper.

The short questionnaire shouldn’t take you more than a few minutes: https://brighterplanet.wufoo.com/forms/green-apps-developers/

Within the broad field of environmental apps, we’re particularly interested in one subset: tools that use hard data to help individuals and small organizations make more informed, sustainable decisions. The EPA has recently put the spotlight on apps like this in their Apps for the Environment Challenge. At Brighter Planet, our Developer Fellowship also provides support for work in this space. We’d love to hear from developers participating in these initiatives and others.

The paper will present our thinking on the state of the green apps ecosystem, explore challenges and opportunities in igniting innovation, and highlight examples of cool apps and developer engagement initiatives.

Thanks for sharing your thoughts. We’ll let you know when the paper is released!

Effective Sustainability

2011-10-19T00:00:00+00:00

Last week I joined a panel on effective sustainability at the World Energy Engineering Conference (WEEEC). I used the findings from our 2010 employee engagement in sustainability survey to argue that effective sustainability programs bring sustainability information to the right people in the right places. Something, according to our survey, far too few organizations are doing.

We’re undertaking a second survey on sustainability in the workplace to see how/if things have evolved over the last year. We’d love to hear your insight on the topic

Carbon Nation

2011-10-14T00:00:00+00:00

{.wrapped} Here’s a guest post from our good friend and former Planeteer Carolyn Barnwell, who’s now involved, among other things, in Carbon Nation, an important new documentary on climate change. Without further ado . . .

Sometimes the best way to promote clean energy is to ignore climate change and focus on things like jobs, money and national security. Carbon Nation is a solutions-based, non-partisan documentary that illustrates why it’s smart to be a part of the new, low-carbon economy. It just came out on DVD and Video On Demand! The movie’s message dovetails perfectly with the trail-blazing carbon data integration that Brighter Planet is doing.

Award-winning director Peter Byck has traveled around the country with the film for over a year. He says, “We seem to have cracked the nut of communicating clean energy, energy efficiency, energy & national security to conservatives, even Tea Party folks.” When it comes to the low-carbon economy, he says, we are not a polarized country. It’s good business, it emboldens national and energy security, and it improves health and the environment. Carbon Nation features a cast of engaging characters from towns big and small, and introduces us to a new wave of American ingenuity. One-armed Texas cotton farmer Cliff Etheredge & his small farm-owning neighbors create the world’s largest wind farm.

Colonel Dan Nolan (US Army, Ret.), an outspoken “Green Hawk,” is working to make military bases and the Pentagon more energy efficient, not only saving fuel, but soldiers’ lives. Col. Nolan says, “Climate change in fact is a national security issue. This is no longer the purview of Birkenstock-wearing tree huggers. Not that there’s anything wrong with that.”

The cast also includes: Richard Branson (CEO, Virgin Group), Thomas L. Friedman (The New York Times), James Woolsey (former CIA Director), Bernie Karl (Geothermal pioneer from Alaska), Denis Hayes (Founder of Earth Day), Van Jones (Founder, Green For All) and more climate change pioneers. I have been fortunate to seen Van Jones speak in person a few times and his openness in this movie showed a more vulnerable and accessible side of him that’s quite moving.
In a final plug, I’ll share the Huffington Post’s review: “Entertaining … endearing … and exceptional. This is not just a film worth seeing, but it is one that is well worth sharing—as widely as possible.” You can watch the trailer, buy the DVD, or even sign up to join over 400 others who have hosted a screening at their website. At the moment I’m writing this, there are only 10 copies left on Amazon . . . I say go for the DVD because it includes tons of special features and even a full second documentary, “Garbage,” which was a Best Documentary winner at SXSW Film Festival!

Join us at the EPA Apps Forum

2011-10-13T00:00:00+00:00

Update: free registration deadline extended to October 28!

Mark your calendars for the EPA’s Apps for the Environment Forum in Arlington, Virgina on November 8. Brighter Planet co-founder Andy Rossmeissl is a featured speaker at the event, in addition to EPA Administrator Lisa P. Jackson and others.

RSVP now (deadline is ~~Tuesday~~ October 28) or read on for more details.

The agenda includes more than just an award ceremony for the EPA’s Apps for the Environment Challenge—the event will “present a vision for the future of environmental apps and mobile technology.”

It promises to be a great afternoon, and attendance is free—just note that you have to register by Tuesday, October 18 28 to attend. If you can’t make it in person, it will also be streamed online.

Greenhouse Gas Protocol releases new standards

2011-10-10T00:00:00+00:00

Last week the Greenhouse Gas Protocol released the final versions of two new accounting standards: the Corporate Value Chain (Scope 3) and Product Life Cycle standards. The new standards provide a harmonized framework for companies to measure and report indirect greenhouse gas emissions throughout their value chain.

This news is very exciting to us at Brighter Planet. From the beginning our goal has been to provide companies and individuals with a comprehensive view of their greenhouse gas emissions. So we’re thrilled to see the establishment of a standard set of rules for calculating indirect emissions, especially as they corroborate many of the decisions we’ve made when building our emissions models.

For example, two of the key challenges identified in the Corporate Value Chain (Scope 3) standard are collecting data on diverse suppliers and activities and providing up-to-date data for calculations. Brighter Planet’s emission models automatically use the most appropriate client-provided primary data or secondary data from our databases. These are kept up-to-date by automated scripts that import updates from authoritative government and industry sources the day they are released. The standard also encourages third-party assurance of calculations. Several of Brighter Planet’s emission models have been verfied by leading carbon validator Det Norske Veritas, an industry first.

With the new standards in place, we hope that many more companies will begin to measure their indirect as well as direct emissions. As World Business Council for Sustainable Development president Björn Stigson points out, this comprehensive view “will help companies make better business decisions and stimulate innovation of products and production methods.”

Engaging Employees on Sustainability

2011-10-07T00:00:00+00:00

Our second annual workplace sustainability survey, currently underway, is analyzing trends and best practices in the rapidly growing field of employee environmental engagement. My recent post over at Environmental Defense Fund business blog explains the details:

Plenty of government agencies and private businesses boast that they are engaging their employees in sustainability programs to green their workplaces. But which employers are really giving their employees the information they need to make their organizations more environmentally-friendly? […]

Head here to read the full post: http://blogs.edf.org/innovation/2011/10/05/how-green-is-your-workplace/

Stamp PDFs with Prawn and Pdftk

2011-10-06T00:00:00+00:00

In order to generate PDFs with a standard template, Brighter Planet uses a combination of Prawn and Pdftk.

First, we generate the content pages:

Here’s what the code for that looks like:

require 'prawn'
Prawn::Document.generate('content.pdf', :top_margin => 126, :right_margin => 72, :bottom_margin => 72, :left_margin => 72) do |pdf|
  pdf.text "Sustainability report for Acme", :size => 18
  pdf.move_down 12
  pdf.text "Executive summary", :style => :bold
  pdf.move_down 12
  pdf.text "Lorem ipsum"
  pdf.start_new_page
  pdf.text "Analysis"
  pdf.move_down 12
  pdf.table([['Lorem', 'ipsum'], ['sit', 'amet']], :width => 468, :header => true)
  pdf.number_pages "Page <page> of <total>", :at => [432, -4], :width => 100
end

Then we apply our standard template:

Which creates the final product (94Kb):

Here’s the Pdftk command to do that:

pdftk content.pdf stamp template.pdf output final.pdf

Final code

require 'prawn'
Prawn::Document.generate('content.pdf', :top_margin => 126, :right_margin => 72, :bottom_margin => 72, :left_margin => 72) do |pdf|
  pdf.text "Sustainability report for Acme", :size => 18
  pdf.move_down 12
  pdf.text "Executive summary", :style => :bold
  pdf.move_down 12
  pdf.text "Lorem ipsum"
  pdf.start_new_page
  pdf.text "Analysis"
  pdf.move_down 12
  pdf.table([['Lorem', 'ipsum'], ['sit', 'amet']], :width => 468, :header => true)
  pdf.number_pages "Page <page> of <total>", :at => [432, -4], :width => 100
end

require 'posix/spawn'
::POSIX::Spawn::Child.new 'pdftk', 'content.pdf', 'stamp', 'template.pdf', 'output', 'final.pdf'

Why not use Prawn’s native `:template` option?

Prawn currently can’t automatically apply a template to every page.

You could force it:

Prawn::Document.generate('bigger_and_dirtier_final.pdf', [...], :template => 'template.pdf') do |pdf|
  # [...]
  pdf.start_new_page :template => 'template.pdf'
  # [...]
end

This is not practical for multi-page tables because you don’t control when new pages start.
The resulting PDF is 200% bigger (180Kb) because the template data is duplicated for every page.
Prawn’s text rendering seems less reliable when using a template. For example, pdf.text "This should be bold", :style => :bold sometimes won’t work (sorry for not reproducing that behavior in my example, didn’t have time.)
Finally you may run into problems with Adobe Reader.

Bottom line: Pdftk is more efficient and reliable than the current version of Prawn for stamping templates.

How Green is Your Workplace?

2011-10-04T00:00:00+00:00

{.wrapped} This month we’re conducting our second annual employee engagement survey, co-sponsored by Conservation International’s Business & Sustainability Council. The survey will benchmark what businesses are doing to involve employees in sustainability and analyze evolutions since last year. We hope you’ll participate and also share the survey with your colleagues. To sweeten the deal, we’ll hand out $200 to a randomly selected respondent!

Survey link after the jump →

Fill out the survey here

As Ceres president Mindy Lubber said in her foreword to our first annual survey report, “Employees represent a critical element in an organization’s efforts to fuse sustainability with profitability. An organization’s success in meeting these goals can rise or fall with its ability to empower and incentivize its employees to integrate sustainability into their day to day activities and decision making. This does require planning and effort. But institutions that have invested in the right systems and structures find that these are yielding not only environmental and social benefits but also helping the bottom line.”

Our survey was the first to benchmark how US organizations are interacting with staff on sustainability and energy efficiency. We compared approaches and effectiveness across industries, identified best practices from successful programs, and reported that while most organizations had begun to engage employees on these issues, few were doing so in a coordinated or effective manner.

Our findings have since been used by municipal governments, businesses, and non-profits to improve their work in this growing and rapidly developing field. In the past year institutions from Walmart to Intel to eBay have learned from experience with engagement programs, organizations such as the National Environmental Education Foundation have adopted research and advancement of sustainability engagement as major priorities, and federal agencies have begun responding to an executive order for quantified progress on this front.

Thanks for taking part and helping spread the word!

Presentation at Strata NYC

2011-09-30T00:00:00+00:00

Last week I made a presentation at Strata NYC, the O’Reilly conference on Big Data. The presentation (embedded below) is in Ignite style, so it’s a total of five minutes long.

Hipmunk, Amtrak, and sustainability: context is everything

2011-09-08T00:00:00+00:00

{.wide}

Today Hipmunk announced that it has added Amtrak trains to flight search results. Reactions have been positive (e.g. VentureBeat, Gadling, Tnooz) and have focused on the lower prices and oftentimes better schedules that trains can offer travelers versus planes on certain routes.

But we like it for a much different reason: it’s a triumph of sustainability.

Right place at the right time

Take a look at the screenshot above; it’s from a Hipmunk search from Philadelphia to Washington, DC. Hipmunk does its usual amazing job of showing differences in price and time—here, you’d save at least $10 and an hour and half with the train option. What it doesn’t show you is that taking the train will result in 21 lbs. CO₂e; the flight, 1,737 lbs., nearly a ton.

The dramatic difference between these modes in environmental impact isn’t a new thing; Amtrak’s been touting it for a while now on its homepage, and it’s one of the stock green travel tips we hear so often. But when you’re trying to get from Point A to Point B, you call up your favorite travel site and hit Search. Let’s face it: who is going to assess the flight options, open another tab for Amtrak.com, run another search, and perform an eyeball comparison of the results between tabs?

Thanks to Hipmunk, this is no longer necessary. Travelers benefit from the saved time and money, and the planet—and all of us—benefit from the resulting decrease in climate change emissions. Hipmunk surely didn’t add this feature for the environmental effects, but they nevertheless deserve a hearty round of applause for the thousands of tons of CO2 that will not be emitted as a result.

How big is the impact?

As a rule of thumb, travelers can assume that Amtrak results will always be lower-impact than flights. But, as they say, there’s safety in numbers, so we added support for this new Hipmunk feature to our Careplane impact-transparency browser plugin:

{.wide}

The difference between training and flying is no joke. Install Careplane, run a search, and see for yourself.

2 easy ways to join the EPA's app challenge

2011-08-29T00:00:00+00:00

As part of Administrator Lisa Jackson’s push to leverage open government data in meeting the its seven priorities, the EPA is hosting a great competition that challenges developers to build applications drawing on publicly available EPA data. The Apps for the Environment challenge is a call for new tools that help individuals and communities address environment and public health issues, with the top apps winning a year of promotion on the EPA website. Submissions are open for another three weeks.

Haven’t submitted anything yet? Using free Brighter Planet tools, you can get started on your own app super quick.

Use Brighter Planet CM1 for carbon and energy calculations. As a green developer, your time is far more valuably spent creating innovative new functionality than it is learning the ins and outs of climate science and reinventing the wheel with your own impact models. CM1’s RESTful JSON/XML API makes it surprisingly easy to build accurate, transparently calculated environmental impact estimates into your app. Since all of CM1’s models involve some use of EPA data, any app you make that uses CM1 will be eligible for the contest.
Pull EPA data from our reference data clearinghouse. You can get normalized, corrected, bona fide EPA data in a variety of useful formats, oriented around business logic rather than obscure EPA publications.

We’re psyched to be submitting a couple of our own apps (Careplane, HootRoot, and Greener Pastures), but we’re confident that using CM1 you can create even better projects in the brief time left until the deadline. May the best apps win!

Madison Ruby 5k

2011-08-22T00:00:00+00:00

Healthy Hackers - Madison Edition

Thanks to all of the healthy hackers who ran with us in the Madison Ruby Conference 5k! It was a magnificent run along State Street’s cafes, up Bascom Hill, through the UW campus, and ending along beautiful Lake Mendota on a pier near the Memorial Union.

Thanks to Justin Love for the photo.

Congratulations to Ryan Horrisberger who finished with an impressive time of 19:49! In second was Collin Schaafsma, followed by our own Andy Rossmeissl in third. Provisional results follow.

Position	Time	Number	Name
1	19:49	30	Ryan Horrisberger
2	23:42	31	Collin Schaafsma
3	23:43	13	Andy Rossmeissl
4	23:45	7	Chris Schmitz
5	23:55	6	David
6	24:11	28	Randall Thomas
7	25:37	10	Matt Yoho
8	25:47	14	Sandro Turriate
9	25:52	26	Paul Kauders
10	26:30	3	Rob Sanheim
11	29:24	21	Derek Kastner
12	29:32	24	Erik Kastman
13	29:33	32	Joe Nelson
14	29:38	34	Unregistered
15	29:52	5	Clark
16	32:47	1	Zach Moneypenny
17	32:48	2	Stacy Moneypenny
18	32:53	15	Brad Grzeslak
19	35:50	23	Justin Love
20	43:26	22	Ben Ortega
21	1:38:ish	18	Matt
22	1:46:ish	11	Veezus Kreis
23	1:46:ish	4	Steven Bristol
24	1:46:ish	27	Tom
25	1:46:ish	9	Coby
26	1:46:ish	33	Brendan
27	1:46:ish	12	Ryan Briones
28	1:46:ish	17	Ray Hightower
29	1:46:ish	29	Josh Mejia
30	1:46:ish	20	Tom

Also, congratulations to our “social runners” who enjoyed the beautiful evening stroll ;)

Let us know if we got your name wrong or left you out and we’ll fix the list ASAP.

A Quarter Billion Strong

2011-08-17T00:00:00+00:00

Yesterday, we sent out a note to tens of thousands of Brighter Planet Visa cardholders thanking them for their effort in creating the industry’s leading environmental card program and in turn the largest consumer carbon offset program in the country. Over 180,000 cardholders have helped to provide financing for 20 clean energy projects throughout the US. Without their support these projects never would have been built and over a quarter billion pounds of CO2, the equivalent of 9.5 million daily commutes, would have been emitted. These projects not only reduce carbon emissions, they provide additional environmental and social value by mitigating electricity costs for family farms and schools, providing green jobs, preserving biodiversity, and helping to clean our air and water.

At a time when climate change and renewable energy development seems to have slipped from our national consciousness, Brighter Planet’s community continues to grow and strengthen. So again, thank you for being leaders and helping to create our clean energy future.

Add node.js/CommonJS style require() to client-side JavaScript with browserify

2011-08-04T00:00:00+00:00

While working on Careplane recently, I ran into a problem that was made easier by JSONPath. I was already enjoying the ability to test my JavaScript with Node.js, Jasmine, and other npm packages. It would be nice if I could get the same package system I have with npm and use it with my client-side JavaScript.

With browserify, now I can!

There are three major benefits to using browserify, which I’ll detail below.

Using npm Modules in Your Client-Side Scripts

In Careplane, I wanted to use the JSONPath npm package. With browserify, I can write the following into my client-side code:

/* clientside.js */
  var jsonpath = require('JSONPath');
  var $ = require('jquery-browserify');
  
  var owned_data = jsonpath.eval(myData, '$.paths[*].to.data[?(@.owner == "Derek")]');
  $('p.important').html(owned_data);

From the command-line, I can create a single JavaScript file (I’ll call it application.js) that contains my code and includes the JSONPath package. I can even bake jQuery into application.js!

> npm install browserify
  > npm install JSONPath
  > npm install jquery-browserify
  > ./node_modules/.bin/browserify -r JSONPath -r jquery-browserify -e clientside.js -o application.js

Now that I have a nicely wrapped application.js, I can include it from a web page, or in this case, the browser plugin I’m developing.

Here’s an example of use from a web page:

<script type="text/javascript" src="application.js"></script>

N.B. Not all npm packages will work client-side, especially ones that depend on core Node.js modules like fs or http.

Organize Your Code

Careplane has a ton of JavaScript split into a separate file for each class. Previously, I was using simple concatenation and a hand-crafted file list to construct an application.js and to determine script load order. Now it can be managed automatically by browserify because each of my class files can require other class files.

For instance, the Kayak class in src/drivers/Kayak.js depends on the Driver class in src/Driver.js. I can now do this:

/* src/Driver.js */

  var Driver = function() {};

  /* ... */

  module.exports = Driver;

/* src/Kayak.js */
  var Driver = require('../Driver')

  var Kayak = function(foo) { this.foo = foo; };
  Kayak.prototype = new Driver();
  
  /* ... */
  
  module.exports = Kayak;

/* src/main.js */
  
  var Kayak = require('./drivers/Kayak'); // paths are relative to src, main.js' cwd
  
  Kayak.getThePartyStarted();

> ./node_modules/.bin/browserify -e src/main.js -o application.js

Super simple!

Uniformity With Testing Environment

I like to run my Jasmine JavaScript tests from the command-line and so does our Continuous Integration system. With jasmine-node, I had to maintain a list of files in my src directory that were loaded in a certain order in order to run my tests. Now, each spec file can use Node.js’ CommonJS require statement to require files from my src directory, and all dependencies are automatically managed.

/* spec/javascripts/drivers/KayakSpec.js */
  
  describe('Kayak', function() {
    var Kayak = require('src/drivers/Kayak');
    /* ... */
  });

> rake examples[KayakSpec] 
  Starting tests
  ............FFF............FF

When I run my specs from the command-line with Node.js (I have an examples rake task that runs node and jasmine), Node’s built-in CommonJS require is used and it recognizes the require statements I wrote into src/drivers/Kayak.js.

I can also run my Jasmine specs from the standard Jasmine web server. All I have to do is create a browserified script that is included before Jasmine runs its tests in my browser.

/* src/jasmine.js */
  var Kayak = require('./drivers/Kayak');  // browserify needs a starting point to resolve all dependencies

# spec/javascripts/support/jasmine.yml
  src_files:
    - spec/javascripts/support/application.js

> ./node_modules/.bin/browserify -e src/jasmine.js -o spec/javascripts/support/application.js
  > rake jasmine:server
  your tests are here:
    http://localhost:8888/
  [2011-08-04 16:15:56] INFO  WEBrick 1.3.1
  [2011-08-04 16:15:56] INFO  ruby 1.9.2 (2011-02-18) [x86_64-darwin10.4.0]
  [2011-08-04 16:15:56] INFO  WEBrick::HTTPServer#start: pid=61833 port=8888

When I visit http://localhost:8888 in my browser, my Jasmine tests all run!

The only drawback is that my code has to be re-browserified whenever it changes. This only adds about a second of overhead while I wait for my watchr script to run the browserification.

If you’d like to take a look at the environment I set up for Careplane, you can check out the source.

I hope you enjoy browserify as much as I have!

New in CM1: carbon equivalents

2011-08-02T00:00:00+00:00

Something we have learned over our 5+ years at Brighter Planet is that, in certain cases, carbon impact can be described most powerfully when it is given in “real life” units. That is, instead of saying a flight has a footprint of 1,045.77 kg CO2e, you say it’s like adding 69 cars to the road for a day.

We released a new feature to CM1 a couple of weeks ago that provides dozens of “equivalents” like this with every JSON and XML response we deliver (example). Reactions so far have been positive, so we’re now marking the feature as public beta.

The conversions are part of our new open-source co2_equivalents library—check out the source for details, including complete citations.

Tronprint Updates

2011-07-22T00:00:00+00:00

This week, some of our servers that were running Tronprint started having DNS problems. Tronprint was unable to connect to our MongoHQ database and our sites crashed. We’ve updated the Tronprint gem to handle connection issues to any database. In the case of a lost connection or a problem saving statistics, Tronprint will simply keep running and wait for the connection to become available again. This means that data could be lost if a connection is never recovered and the application process quits. However, the connection failure will not affect the operation of your site.

We’ve also created a Twitter account to keep you updated on new versions and features.

New biogas offset project

2011-07-06T00:00:00+00:00

Our latest offset project, the Wewoka Biogas Project, is Brighter Planet’s first ever biogas project. Once again we’re working with our partner NativeEnergy to support a small project that fights climate change and strengthens the local community. The project’s emissions reductions will be validated and verified under the Verified Carbon Standard using its landfill gas protocol.

Since 1925, the family-owned Commercial Brick Corporation has supplied materials to homes and businesses throughout the country. Today they are the largest employer in rural Wewoka, IL, supporting hundreds of families. With rising Natural Gas prices they looked for an alternative fuel to heat their kilns and found an unexpected source: the landfill next door.

Municipal solid waste landfills are the second largest source of human-related methane pollution in the United States. As waste in landfills decomposes anaerobically (without oxygen) it produces methane, a powerful greenhouse gas with 21 times the climate impact of CO₂. But this polluting biogas can be captured and put to use. In Wewoka, it will provide renewable fuel for Commercial Brick’s kilns.

To capture the methane, vertical gas wells installed in the landfill will be connected to a central blower. The blower will then push the methane through a half-mile pipeline to the brick kilns, which are being retrofitted to burn biogas just like regular natural gas. If the kilns malfunction, a flare will burn the excess gas at the landfill. The project will avoid the equivalent of about 25,000-30,000 metric tonnes of CO₂ per year, and this reduction will be validated and verified under the Verified Carbon Standard.

Without revenue from offset sales the kiln retrofits and pipeline and blower construction would be too expensive to justify the investment. It’s thanks to Brighter Planet’s cardholders and customers that this project has become reality.

A new perspective on air travel management

2011-06-28T00:00:00+00:00

These days more and more organizations are measuring the carbon impacts of employee air travel programs. That’s a good thing. Unfortunately, most are using a simplistic approach that leaves one of their hands tied when it comes to managing those programs for reduced carbon impact. Correcting this business intelligence shortfall is the focus of our latest research paper, an in-depth modeling analysis of more than a decade of global airline industry data.

Huffington Post ran an article on the report today, and the paper should speak for itself, but among the highlights are:

Huge efficiency variation. Fuel use per passenger per mile varies more than tenfold across the airline industry, a fact most carbon calculations ignore to their detriment in terms of reporting accuracy, and more importantly, in terms of carbon reduction opportunity.
New sustainability potential. Case studies of more than 300,000 employee flights at two major global corporations show that choosing carbon-efficient itineraries on existing routes, without cutting flights or increasing costs, can slash emissions by as much as 40%.
Real-world airline rankings. This study is far from the first to rank airlines on sustainability, but few predecessors have accounted for real-world passenger volumes, load factors, freight shares, aircraft efficiencies, seating configurations, and route characteristics to provide as accurate a rating. Ryanair leads the 20 largest airlines in the international market, followed by Singapore Airlines and Continental. In the U.S. domestic market, Continental comes first, followed by JetBlue and Frontier.
Revealing industry trends. Air travel efficiency has improved 20% since 2000, preventing the equivalent of an entire year’s worth of flights over that time, and saving airlines (and thus travelers) 33 billion dollars on jet fuel at a time both were struggling in an ailing economy.

We ran this analysis by turning our CM1 flight model on itself to process databases covering more than 9 billion passengers on 130 million worldwide flights over 10 years. That should be sufficient to qualify as data-driven decision making.

Stream parser with Ragel and Ruby

2011-06-14T00:00:00+00:00

You can use Ragel to make simple stream parsers in Ruby. By “stream parser,” I mean one that reads in files a chunk at a time instead of all at once—thereby keeping memory use constant.

Say you have a file like

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer a
tristique lectus. Vestibulum ante ipsum primis in faucibus orci luctus et
aliquet laoreet, iacSTARTFOOThere are lots of great ideas here.ENDFOOulis
a lorem. Integer interdum, dolor aliquam accumsan eleifend, nisl tortor
mollis ipsum, et semper arcu mi nec felis. Nunc scelerisque cursus dolor
eu tristique. Mauris porta pulvinar dolor. Integer egestas lacinia leo, ut
mollis sapien fermentum non. Maecenas ultricies nibh at justo ornare eu
ullamcorper justo aliquet. Cras id augue eget nunc auctor mattis vitae
quis massa. STARTFOOYou just have to look closelyENDFOOMauris suscipit
justo in erat scelerisque imperdiet.

You want to pull out

There are lots of great ideas here.
You just have to look closely

As I show in my ragel_ruby_examples tests, you could even read the stream 1 byte at a time.

Here’s the Ragel part:

machine simple_tokenizer;
  action MyTs {
    my_ts = p
  }
  action MyTe {
    my_te = p
  }
  action Emit {
    emit data[my_ts...my_te].pack('c*')
    my_ts = nil
    my_te = nil    
  }
  foo = 'STARTFOO' any+ >MyTs :>> 'ENDFOO' >MyTe %Emit;
  main := ( foo | any+ )*;

…and here’s the Ruby reading/buffering mechanism…

CHUNK_SIZE = 1_000_000 # bytes (instead of reading in the whole file all at once)
  # Note: use with simple_tokenizer
  def perform
    pe = :ignored
    eof = :ignored
    %% write init;
    # % (this fixes syntax highlighting)
    leftover = []
    my_ts = nil
    my_te = nil
    File.open(path) do |f|
      while chunk = f.read(CHUNK_SIZE)
        data = leftover + chunk.unpack('c*')
        p = 0
        pe = data.length
        %% write exec;
        # % (this fixes syntax highlighting)
        if my_ts
          leftover = data[my_ts..-1]
          my_te = my_te - my_ts if my_te
          my_ts = 0
        else
          leftover = []
        end
      end
    end
  end

Alternatively you could use Ragel’s scanner functionality:

machine simple_scanner;
  action Emit {
    emit data[(ts+8)..(te-7)].pack('c*')
  }
  foo = 'STARTFOO' any+ :>> 'ENDFOO';
  main := |*
    foo => Emit;
    any;
  *|;

Which requires buffering code like:

CHUNK_SIZE = 1_000_000 # bytes (instead of reading in the whole file all at once)
  # Note: use with simple_scanner
  def perform
    pe = :ignored
    eof = :ignored
    %% write init;
    # % (this fixes syntax highlighting)
    leftover = []
    File.open(path) do |f|
      while chunk = f.read(CHUNK_SIZE)
        data = leftover + chunk.unpack('c*')
        p ||= 0
        pe = data.length
        %% write exec;
        # % (this fixes syntax highlighting)
        if ts
          leftover = data[ts..pe]
          p = p - ts
          ts = 0
        else
          leftover = []
          p = 0
        end
      end
    end
  end

Again, you can see more at ragel_ruby_examples, specifically simple_tokenizer.rl.

Final note: I realize this isn’t precisely a parser or even a tokenizer… but these sorts of examples are what I would have wanted when I was getting started with Ragel and Ruby. What’s more, hopefully the Ragel community will chime in and improve the examples.

A Pattern for JavaScript Events

2011-06-10T00:00:00+00:00

While working on Hootroot and Careplane, I found myself getting frustrated with the way I was having handling events. Over time, however, I stopped fighting the language and learned a pattern that I believe is easiest to test and read.

I’ll work with a simple example to show you my thought process.

Initially, I started handling my events with standard closures:

//Rocket.js

Rocket = function(location) {
  this.location = location;
};

Rocket.prototype.ignite = function() { /* ... */ };
Rocket.prototype.scrub = function() { /* ... */ };

Rocket.prototype.launch = function() {
  var rocket = this;
  $.ajax('/launch_code', {
    data: { location: this.location },
    success: function(data) {
      if(rocket.isReady()) {
        alert('Launching from ' + rocket.location);
        rocket.ignite(data.launchCode);
      } else {
        alert('Not ready to launch!');
      }
    },
    error: function() {
      alert('Failed to get launch code for ' + rocket.location);
      rocket.scrub();
    }
  });
};

//RocketSpec.js

describe('Rocket', function() {
  describe('#launch', function() {
    var rocket;
    beforeEach(function() {
      rocket = new Rocket('Cape Canaveral, FL');
      fakeAjax({urls: {'/launch_code': {successData: '{ "launchCode": 12345 }'}}})
      spyOn(rocket, 'ignite');
      spyOn(rocket, 'scrub');
    });

    it('ignites if ready', function() {
      rocket.isReady = function() { return true; };
      rocket.launch();
      expect(rocket.ignite).toHaveBeenCalled();
    });
    it('waits if not ready', function() {
      rocket.isReady = function() { return false; };
      rocket.launch();
      expect(rocket.ignite).not.toHaveBeenCalled();
    });
    it('scrubs if a bad launch code is given', function() {
      fakeAjax({urls: {'/launch_code': { errorMessage: '{ "error": "too bad" }'}}})
      rocket.launch();
      expect(rocket.scrub).toHaveBeenCalled();
    });
  });
});

Because of the way this works in JavaScript, I had to assign the this that referred to the current instance of Rocket to a temporary variable that is referenced in the event handlers. This seemed kludgy to me, and I soon discovered the $.proxy() method that jQuery (and other frameworks similarly) provide:

//Rocket.js

Rocket = function(location) {
  this.location = location;
};

Rocket.prototype.ignite = function() { /* ... */ };
Rocket.prototype.scrub = function() { /* ... */ };

Rocket.prototype.launch = function() {
  $.ajax('/launch_code', {
    data: { location: this.location },
    success: $.proxy(function(data) {
      if(this.isReady()) {
        alert('Launching from ' + this.location);
        this.ignite(data.launchCode)
      } else {
        alert('Not ready to launch!');
      }
    }, this),
    error: $.proxy(function() {
      alert('Failed to get launch code for ' + this.location);
      this.scrub();
    }, this)
  });
};

//RocketSpec.js

describe('Rocket', function() {
  describe('#launch', function() {
    var rocket;
    beforeEach(function() {
      rocket = new Rocket('Cape Canaveral, FL');
      fakeAjax({urls: {'/launch_code': {successData: '{ "launchCode": 12345 }'}}})
      spyOn(rocket, 'ignite');
      spyOn(rocket, 'scrub');
    });

    it('ignites if ready', function() {
      rocket.isReady = function() { return true; };
      rocket.launch();
      expect(rocket.ignite).toHaveBeenCalled();
    });
    it('waits if not ready', function() {
      rocket.isReady = function() { return false; };
      rocket.launch();
      expect(rocket.ignite).not.toHaveBeenCalled();
    });
    it('scrubs if a bad launch code is given', function() {
      fakeAjax({urls: {'/launch_code': { errorMessage: '{ "error": "too bad" }'}}})
      rocket.launch();
      expect(rocket.scrub).toHaveBeenCalled();
    });
  });
});

The problem now is there are all sorts of functions hanging around within Rocket#launch() that are a bit difficult to test in a straightforward manner. Solution: create some functions on Rocket that act as event handlers.

// Rocket.js

Rocket = function() {
  this.location = 'Cape Canaveral, FL';
};

Rocket.prototype.igniteWhenReady = function(data) {
  if(this.isReady()) {
    alert('Launching from ' + this.location);
    this.ignite(data.launchCode);
  } else {
    alert('Not ready to launch!');
  }
};

Rocket.prototype.invalidLaunchCode = function() {
  alert('Failed to get launch code for ' + this.location);
  this.scrub();
};

Rocket.prototype.launch = function() {
  $.ajax('/launch_code', {
    data: { location: this.location },
    success: $.proxy(this.igniteWhenReady, this),
    error: $.proxy(this.invalidLaunchCode, this)
  });
};

//RocketSpec.js

describe('Rocket', function() {
  var rocket;
  beforeEach(function() {
    rocket = new Rocket('Cape Canaveral, FL');
    spyOn(rocket, 'ignite');
    spyOn(rocket, 'scrub');
  });

  describe('#launch', function() {
    // we don't need to test launch() because we'd really just be testing $.ajax
  });

  describe('#igniteWhenReady', function() {
    it('ignites if ready', function() {
      rocket.isReady = function() { return true; };
      rocket.igniteWhenReady({ launchCode: 12345 });
      expect(rocket.ignite).toHaveBeenCalled();
    });
    it('does not ignite if not ready', function() {
      rocket.isReady = function() { return false; };
      rocket.igniteWhenReady();
      expect(rocket.ignite).not.toHaveBeenCalled();
    });
  });
  describe('#invalidLaunchCode', function() {
    it('scrubs if a bad launch code is given', function() {
      rocket.invalidLaunchCode();
      expect(rocket.scrub).toHaveBeenCalled();
    });
  });
});

This is much cleaner and easier to test, but those lingering $.proxy() calls were bugging me. They also made debugging a bit more tedious when having to step through the calls to $.proxy.

My solution: stop fighting with this and create my own event proxy pattern. Testing is now much cleaner.

//Rocket.js

Rocket = function(location) {
  this.location = location;
};

Rocket.prototype.ignite = function() { /* ... */ };
Rocket.prototype.scrub = function() { /* ... */ };

Rocket.events = {
  igniteWhenReady: function(rocket) {
    return function(data)
      if(rocket.isReady()) {
        alert('Launching from ' + rocket.location);
        rocket.ignite(data.launchCode);
      } else {
        alert('Not ready to launch!');
      }
    };
  },

  invalidLaunchCode: function(rocket) {
    return function() {
      alert('Failed to get launch code for ' + rocket.location);
      rocket.scrub();
    };
  }
};

Rocket.prototype.launch = function() {
  $.ajax('/launch_code', {
    data: { location: this.location },
    success: Rocket.events.igniteWhenReady(this),
    error: Rocket.events.invalidLaunchCode(this)
  });
};

//RocketSpec.js

describe('Rocket', function() {
  var rocket, igniteWhenReady, invalidLaunchCode;
  beforeEach(function() {
    rocket = new Rocket('Cape Canaveral, FL');
    spyOn(rocket, 'ignite');
    spyOn(rocket, 'scrub');
    igniteWhenReady = Rocket.events.igniteWhenReady(rocket);
    invalidLaunchCode = Rocket.events.invalidLaunchCode(rocket);
  });

  describe('.events', function() {
    describe('.igniteWhenReady', function() {
      it('ignites if ready', function() {
        rocket.isReady = function() { return true; };
        igniteWhenReady({ launchCode: 12345 });
        expect(rocket.ignite).toHaveBeenCalled();
      });
      it('does not ignite if not ready', function() {
        rocket.isReady = function() { return false; };
        igniteWhenReady();
        expect(rocket.ignite).not.toHaveBeenCalled();
      });
    });
    describe('.invalidLaunchCode', function() {
      it('scrubs if a bad launch code is given', function() {
        invalidLaunchCode();
        expect(rocket.scrub).toHaveBeenCalled();
      });
    });
  });
});

The result is much more readable code, easier debugging (when absolutely necessary), and simpler testing without all those nested closures and AJAX stubs. As an added bonus, you get to keep the this in your event handlers that refers to the event itself.

This experience has led me to believe that a lot of the problems CoffeeScript tries to solve (like function binding) can really just be solved using good, simple JavaScript coding practices. I’m happy to hear from anyone who has a better pattern or has had similar experiences.

Bringing sustainability to the heart of commerce

2011-05-12T00:00:00+00:00

“The world’s most advanced carbon calculator may already be in your wallet.”

That’s the tagline on a postcard we’re distributing today here at the Ceres conference in Oakland, where we’re announcing a major new partnership with MasterCard. Powered by Brighter Planet, MasterCard’s Carbon Emissions Reporting initiative is a first-of-its-kind sustainability solution that will efficiently bring advanced carbon analysis to more businesses worldwide than any other service we know of.

Businesses care more and more about managing travel sustainability for reporting, brand, efficiency, and employee engagement purposes. Last year 39 percent of Global 500 companies analyzed and reported their employee travel footprint, up from 34 percent the year before. But getting good carbon info by traditional means, whether compiled in-house, by an outside consultant, or with specialized software, costs time and money—and that means it’s done less frequently, and less carefully, than it could be, which compromises environmental and economic potential.

It’s this problem that MasterCard and Brighter Planet are targeting with our new carbon intelligence partnership. The concept is simple:

Companies of all sizes use corporate cards for flights, hotel stays, car rentals, etc.
MasterCard helps these companies aggregate and analyze all of this spending data, delivering sophisticated business intelligence through their Enhanced Data offering.
Brighter Planet steps in to deliver the science, analyzing all of this accumulated travel transaction data to calculate carbon footprints for flights, rental cars, hotels, and other purchases. Our cloud-based CM1 platform works behind the scenes, adding authoritative footprint data to the other spending details already in the MasterCard system for use by clients.
Corporate card accountholders gain access to employee travel carbon data through the same MasterCard software they already use to manage purchasing card business intelligence online. This new value comes with no new costs, no new software programs to adopt, and no new partnerships to manage.

This is the direction we believe the next generation of carbon and energy data management solutions is headed, and it’s just the type of program we built CM1 to power. As organizations begin to contemplate not just measurement but active management of sustainability—and as global business data ecosystems are increasingly interconnected—we think MasterCard’s program will serve as a powerful example of what’s just now becoming possible.

Tronprint is Now in Public Beta

2011-05-05T00:00:00+00:00

Our Tronprint plugin for Heroku, which measures your cloud app’s carbon footprint, has just graduated from private beta to public beta! This means anyone with a Heroku account can try it out. Of course, if you don’t use Heroku, you can still install the Tronprint gem in your existing Ruby or Rails application.

We’d love to hear your feedback, so feel free to tweet or email us.

Introducing Bombshell: custom interactive consoles for your Ruby libraries

2011-04-20T00:00:00+00:00

One of the cool features of carbon, the Ruby library for our CM1 web service, is its built-in interactive console for experimenting with the service. At Brighter Planet we use carbon’s console all the time to construct one-off calculations and perform simple analyses.

We think the built-in library console could be a pretty useful pattern for other libraries; they allow developers to explore your library and its API without having to contrive host applications just to test things out.

Building carbon’s console, however, was a major pain. IRB, the console’s basis, is infamous for its poor documentation and, with all due respect, antiquated API. So we extracted all the little tricks and nuances that went into carbon’s console and put them in a library.

That library is Bombshell. To use it, just create a class for the console in your library and hook it into Bombshell. Instance methods on your class are “commands” in your console:

module FooGem
  class Shell < Bombshell::Environment
    include Bombshell::Shell
    prompt_with 'fooshell'
    def report
      puts FooGem::Foo.new.report! # Do something with your library here
    end
  end
end

fooshell> report
All is well!

Bombshell provides callback hooks, supports arbitrary-depth subshells, and handles tab-completion automatically.

Check out the README, the docs, and carbon’s shell class (and subshell) for a more complex (production) example.

Thanks to Aslak Hellesøy, whose aruba Cucumber steps made it possible to write a pretty thorough test suite for Bombshell.

Healthy Hacker Fun Run photos

2011-04-12T00:00:00+00:00

Thanks to all who ran!

CodeConf 5k Results

2011-04-11T00:00:00+00:00

The results are in! We sponsored a morning “Healthy Hacker” 5k run along San Francisco’s Embarcadero. It was a beautiful morning for a run, and we all at Brighter Planet had a great time. Thanks to everyone who participated!

Number	Name	Total Time
39	Jeremy Ashkenas	21:03.5
49	Mark Headd	21:24.6
37	Ian Young	21:27.7
43	Ethan Herdrick	21:42.1
56	Douglas Sellers	22:10.6
26	Jacob Kaplan-Moss	23:09.3
51	Kasima Tharnpipitchai	23:16.8
02	Sean Bleier	23:20.3
11	Scott Chacon	23:22.6
53	Mislav Marohnić	23:23.0
05	Seth Fitzsimmons	23:58.3
25	Piet Jaspers	24:12.2
83	Jeremy Yun	24:52.1
19	Etienne Segonzac	25:25.6
29	Florian Le Goff	26:19.9
36	Jelle Vandebeeck	27:13.8
99	Chris Bowns	27:19.4
13	Clint Shryock	28:00.7
20	Matthew Aebersold	28:21.1
04	Derek Kastner	28:51.8
30	John Crepezzi	29:07.4
34	Aubrey Holland	29:23.2
32	Baldur Gudbjornsson	29:53.1
85	Jose Fernandez	31:44.5
24	Clint Ecker	31:49.4
50	Ryan Williams	33:41.6
40	Ilya Shindyapin	33:48.3
07	Rob Tsuk	34:36.4

We also had a great time at CodeConf. It was very well put together and the folks at Github deserve serious kudos. The speakers all had great things to say and the social events were creative and top-notch.

Our carbon models got certified, and what this means for you

2011-04-05T00:00:00+00:00

Today we announced that Det Norske Veritas (DNV) has reviewed and certified carbon models in our CM1 web service as complying with the major international carbon standards. This makes Brighter Planet one of the first in the carbon software industry to get a third-party seal of approval for standards compliance, and the first open-source carbon software provider to do so.

The certification process was quite involved. DNV took months to review our carbon models, examining calculation methodologies, source code, data sources, and documentation to check conformity with three global standards: the Greenhouse Gas Protocol, ISO 14064, and the Climate Registry. This is a crucial piece of our strategy to ensure the highest transparency and integrity in enterprise greenhouse gas calculations.

It’s big news for Brighter Planet and our clients, because it validates the methodologies and data sources that power the carbon calculations in our flight, automobile, meeting, and lodging modules, among others. Ensuring authoritative carbon accounting practices is becoming increasingly important as the emissions software industry matures, and the report from DNV, the preeminent organization in carbon verification, is a critical step.

Switching over to certified calculations on CM1 is a breeze—we’ll be showing you how in additional blog posts over the course of the week. (Short version: just submit your calculation queries to certified.carbon.brighterplanet.com instead of carbon.brighterplanet.com.)

Resque, the rand() method, and Kernel.fork

2011-03-30T00:00:00+00:00

We had a seemingly impossible number of tmpdir collisions once we switched our reference data web service from DelayedJob to Resque.

The culprit was calling rand() in worker processes that are forked off the main process by Resque:

$ irb
> Kernel.fork { puts rand.to_s }
  0.536506566371644
> Kernel.fork { puts rand.to_s }
  0.536506566371644              # the same
> Kernel.fork { puts rand.to_s }
  0.536506566371644              # the same

Don’t forget to call srand!

$ irb
> Kernel.fork { srand; puts rand.to_s }
  0.232438861240513
> Kernel.fork { srand; puts rand.to_s }
  0.363543277594837
> Kernel.fork { srand; puts rand.to_s }
  0.000133387538081786

Now it’s fixed in the remote_table gem via this commit.

Carbon.js

2011-03-18T00:00:00+00:00

Lately, I’ve been working on a Google Maps mashup that calculates CO2 emissions for automobile, bus, and rail trips. Since Google Maps has such a great JavaScript API, I decided to write the application almost entirely in JavaScript. Thus, Carbon.js was born!

Carbon.js makes it simple to calculate emissions. Its design is similar to the Ruby carbon gem. For any class that represents an “emission activity”, e.g. an automobile trip, you can extend it with Carbon.js to give it the ability to perform calculations.

Let’s look at an example.

RentalCar = function() {};
Carbon.emitter(RentalCar, function(emitter) {
  emitter.emitAs('automobile');
  emitter.provide('make_model');
  emitter.provide('weekly_distance');
  emitter.provide('timeframe');
});

var focus = new RentalCar;
focus.make_model = 'Ford Focus';
focus.weekly_distance = 436;
focus.timeframe = '2010-03-08/2010-03-14';

focus.getEmissionEstimate(function(estimate) {
  alert("My Focus' emissions for the rental period of March 8th-14th are: " + estimate.value());
});

As you can see, the configuration defined in the Carbon.emitter call maps properties on an instance of RentalCar to characteristics defined in automobile’s characteristics API. In order to calculate emissions, a call to getEmissionEstimate with a callback function parameter is required. Within that callback, you can update HTML on a page with the result.

Future Improvements

Carbon only maps properties of an object to characteristics. It will be simple to allow an instance function to be mapped to a characteristic.
Carbon.js requires that you use jQuery. One improvement would be to use platform-agnostic XHR and proxy functions, or intelligently detect available libraries, like Prototype, MooTools, etc.
For DRYness sake, Carbon.js operates on classes. It may be helpful to be able to decorate any JavaScript object on the fly.

What you should know about mysql2 memory usage

2011-03-15T00:00:00+00:00

If you’re using mysql2, you should be aware of a memory usage issue:

# mysql2 gem - no way to avoid using a lot of memory if you're streaming a lot of rows
client = Mysql2::Client.new(:host => "localhost", :username => "root")
results = client.query("SELECT * FROM users WHERE group='githubbers'")

# mysql gem - keep memory usage flat if you're streaming a lot of rows
dbh = Mysql.init
dbh.connect "localhost", "root"
dbh.query_with_result = false
dbh.query("SELECT * FROM users WHERE group='githubbers'")
results = dbh.use_result

While working on our reference data web service, I ran these benchmarks:

Exporting 5,000 rows using mysql (the “old” gem) stays flat on memory
Exporting 5,000 rows using mysql2 takes an ever-increasing amount of memory (not good!)

The problem

The author of the gem in question, mysql2, knows about the issue. In a nutshell, the gem’s use of mysql_store_result (as opposed to mysql_use_result) leads the underlying libmysql library to always load entire resultsets into memory… even if :cache_rows => false is passed as a runtime option. A :streaming => true option would make perfect sense!

The solution

I had to modify my gem, mysql2xxxx (which provides mysql2csv, mysql2json, and mysql2xml) to use the “old” mysql gem.
If you’re using mysql2 (it’s the default on Rails 3!) then be aware that processing huge resultsets has a different memory impact than it did with mysql.
Vote up the issue on github… it would be nice to optionally use mysql_use_result!

I believe mysql2 has a promising future and this memory problem will probably be gone soon. Thanks brianmario!

Greensburg named Wind Project of the Year

2011-03-09T00:00:00+00:00

Greensburg Wind Farm, one of the community carbon projects in our offset portfolio, has been named Wind Project of the Year by Renewable Energy World. Brighter Planet is a charter supporter of the wind farm—alongside Green Mountain Coffee Roasters, Ben & Jerry’s, Stonyfield, CLIF Bar, Aveda, Clean Air-Cool Planet, and Reverb—providing key funding from groundbreaking in 2009 through through project completion in 2010.

The Excellence in Renewable Energy awards were granted in five categories—including solar, geothermal, biomass, and hydro in addition to wind—with judges considering “the innovative technology that was employed as well as the projects’ impact on the industry at large and on the communities in which they were installed.”

We source top-quality projects that meet our rigorous offset policy, and it’s great to see one of our projects getting this recognition from industry analysts. Kudos to our partner NativeEnergy, whose vision and execution were critical in getting the project built. And many thanks to all you Brighter Planet cardholders out there whose daily support is instrumental in making this and other projects a reality.

As President Obabma said in a speech last year, Greensburg is “a global example of how clean energy can power an entire community—how it can bring jobs and businesses to a place where piles of bricks and rubble once lay.”

Virtual servers, real impact

2011-03-08T00:00:00+00:00

Last week we announced Tronprint, our Ruby library for measuring an application’s carbon footprint in real time. There’s a subtlety to the way that my colleague Derek designed Tronprint that didn’t hit me for a while: as a piece of monitoring software it’s “inside-out” rather than “outside-in.” It’s a simple distinction that’s going to let us continue to address sustainability in this new era of cloud computing.

First, let’s look at an old-school web application:

{.wide}

Calculating the application’s footprint in this case is pretty easy—just base your calculation on the electricity used by the server. Unfortunately this infrastructural design is rarely ever seen in the wild anymore. Virtualization presents one challenge:

{.wide}

How do you allocate impact among virtual servers? If you control the hypervisor (the coordinating software on the physical host server), presumably you would have access to some data that would help determine this. But oftentimes owners of virtual servers do not have access to this data.

Let’s take this a step further and add load balancing:

{.wide}

Modern load-balanced architectures can have an arbitrary number of “instances” of the application running on an arbitrary number of virtual machines. At this point you can see our analysis breaking down: the physicality of these computations is both mysterious and irrelevant.

The abstraction of physical resources reaches a kind of apotheosis with Platform-as-a-Service (PaaS) offerings like Heroku:

Routing mesh? Dyno grids? When Seamus, Robbie, and I were having lunch with the Heroku folks last week, they emphasized that they’re trying to keep the Heroku experience entirely free of the notion of physical servers.

This is a good thing. But as our applications grow ever more distant from the silicon they run on, it’s easy to lose sight of the fact that those circuits are electrical circuits—the server may be virtual, but the impact’s very real.

So, as the operator of an application that lives inside of a grid inside of a mesh inside of a platform inside of a virtualized datacenter, how are you to know your application’s footprint? Having done everything they can to keep you from the physical, are your service providers unwittingly hamstringing your sustainability agenda?

The answer to this question, it turns out, is the simple distinction that sets Tronprint apart: monitor your application’s resource use from the inside out. In a supervirtualized architecture, after all, the only thing you have any truly predictable control over is the application itself.

I like to imagine Tronprint as being a born-and-bred native resident of the cloud. There are dozens of layers of technology keeping the cloud alive: servers, routers, load balancers, datacenters. But just as we don’t need advanced knowledge of astrophysics to carry on our daily lives here on our planet, Tronprint doesn’t care about all that. It lives on the surface, among the applications, helping them out.

Subtle, right? I wonder if Derek knew just how clever he’d been :)

Exploring data in partnership with Google

2011-03-07T00:00:00+00:00

Google’s DSPL and Public Data Explorer help us improve our reference data web service by visualizing it. Working with Jürgen Schwärzler, a statistician for Google, we laid the foundation for an automobile industry dataset:

{.wide}

It’s a demonstration of the power of the cloud to drive value-added aggregation, errata cleanup, record linkage, and ultimately creative and commercial use.

We look forward to working more with Google in the future to develop more datasets (including an upcoming flight industry dataset) and improve existing ones.

Tronprint: Measure the footprint of your cloud application

2011-03-02T00:00:00+00:00

One of the major factors contributing to an organization’s sustainability, especially for web application companies, is the carbon footprint associated with IT operations. Gartner Research has estimated that the IT sector accounts for 2% of global greenhouse gas emissions and that, “despite the overall environmental value of IT, Gartner believes this is unsustainable.”

One of the ways many organizations cut costs and emissions is by outsourcing and virtualizing their IT operations. For instance, many web startups host their applications with services like Heroku and Engine Yard. Outsourcing and virtualization helps, but the main disadvantage is that it’s difficult to monitor the power usage (and footprint) of your application.

This is where Tronprint comes in. Tronprint keeps a running total of your application’s resource usage as it runs. This resource usage translates into the total amount of electricity used by your application. You can even tell Tronprint where your application is hosted, and it will take the server’s local electricity source into account when coming up with an emission estimate. For instance, a server powered by a coal power plant is dirtier than one powered by natural gas.

Tronprint allows you to take action in three ways:

Simply knowing your footprint helps you report reliable sustainability metrics.
You can use Tronprint to help you choose a hosting location that uses cleaner energy sources.
By improving the computational efficiency of your application, you reduce emissions—and have metrics to prove it.

If you host your application on Heroku, you can add Tronprint as an “Add-On.” The Heroku Add-On is currently in private beta, but will be moving to public beta in the near future.

You can also install the Tronprint gem today in any Ruby or Rails application. There are detailed instructions at rdoc.info.

Bringing carbon calculations to TripIt

2011-02-22T00:00:00+00:00

It’s a privilege to be posting here on Safety in Numbers, and particularly exciting to do so as Brighter Planet’s first Developer Fellow. I was an early Brighter Planet cardholder and have watched the team closely, so it’s great to get a chance to work with them.

For a few weeks now, I have been working with Brighter Planet CM1 API to create TripCarbon, an automated tool that calculates carbon output from TripIt itineraries. If you’re not familiar with Tripit, you can send it your travel confirmation emails and it creates amazing online itineraries with real-time status updates, loyalty program points tracker (for pro users), refund tracking, and more. I’ve been using TripIt for several years, and it’s one of the most powerful web tools I use.

Adding carbon data to TripIt will allow the many users of Tripit to easily and automatically see the carbon use of their trips. Why is this useful? Armed with this knowledge, they can offset their trips or make trip-planning decisions which minimize carbon use. A former employer of mine offset all business travel; with this tool, it will be much easier to offset the appropriate amount of carbon with minimal work. Personally, it’s great to be working on something that I’ll use regularly.

Working with the CM1 tool has been a breeze. Since I’ve been using Ruby on Rails, I’ve been able to use the Carbon gem to easily extend my Rails models. I’ve also used the handy Conversions gem to handle unit conversions.

After setting up my API key and adding the Carbon gem to my Gemfile, calculating emissions for my flight model was as simple as providing data from TripIt’s API:

emit_as :flight do
    provide :origin_airport
    provide :destination_airport
    provide :airline
    provide :segments_per_trip
    provide :trips
    provide :start_date, :as => :date
    provide :aircraft
    provide :distance_in_kilometers, :as => :distance_estimate
    provide :timeframe
end

The data I get from TripIt isn’t always consistent, since it gets pulled from confirmation emails, but CM1 is amazingly flexible with data inputs. For instance, it recognize various code types for airlines and aircrafts. Or if the distance isn’t available, it can calculate it automatically from the origin and destination airports. CM1 returns not only the emissions estimate, but also a link to the full methodology, which I can then add to the relevant TripIt note.

I’m still working on my app, but I look forward to sharing it with you soon. Thanks for reading.

Scott Bulua

Developer Fellow

New electricity model goes live

2011-02-11T00:00:00+00:00

We’ve just switched on version 0.0.1 of our newest carbon model, Electricity Use, hosted on our CM1 footprint calculation platform.

The new tool takes electricity carbon calculation functionality that’s long been an integral part of many of our existing models, and packages it in a standalone module for use in apps dealing more directly with electricity data.

The model can be used to measure carbon impacts in any application that processes electricity data, from smart grid metering or billing utilities to corporate accounting and ERP systems. We’ve already got developers working to deploy the new plug-in in their apps. Check out a sample calculation here.

Powering the calculations are data from the EPA’s eGRID, the definitive source for data on geographic variation in grid electricity sources in the US. Upcoming versions will expand the tool’s functionality to incorporate even higher resolution data on fluctuations in electric sources.

A closer look at public data cleanup

2011-02-08T00:00:00+00:00

Our CM1 carbon models depend on lots of public energy and emissions data relating to things like buildings and transportation—mostly from government sources like the EIA, BTS, and EPA. Whenever you use or mash up a large dataset you’ll likely run into issues like inconsistent file layouts, awkward formats, and human error. So file cleanup is a large part of the process we go through when plugging data into our system and making them available in our free data clearinghouse. Here’s a quick look at three of the main things we do; we’ll delve into more specifics in subsequent posts:

Error correction. Most datasets are pretty good, but with some containing millions of data points, human error is bound to work its way in. We use search algorithms to identify typos and outliers, and then manually correct or delete flawed entries.

For example: The EPA Fuel Economy Guide files from 1985 through 2010 contain various typos and inconsistencies. We list corrections to each of these in an errata file that we apply during the import process.
Restructuring. Some databases have attribute names that change over time. Others have attributes that contain both numerical data and numerical codes and so require special analysis techniques. In both of these cases we parse the data into a single format that is convenient for calculations.

For example: The EIA’s Commercial Buildings Energy Consumption Survey includes codes like 99999 for nautral gas use when a building never uses natural gas. The EPA Fuel Economy Guide uses four different sets of attribute names from 1985 through 2010.
Data extraction. Some data come from report tables that are only available as a PDF file or in print. We manually extract these data and make them available in formats like CSV, JSON, XML, and SQL that can plug into the modern information ecosystem.

For example: The APTA Public Transportation Fact Book Appendix A is only available in PDF format.

We take all the public data we clean up for our clients’ use and post it on our data site so others can benefit as well. It’s available for download in multiple formats. And it’s kept up to date using automated import programs that crawl government agency websites and automatically import the latest data updates as soon as they’re available.

Welcome Matt Colyer, our second Developer Fellow

2011-02-07T00:00:00+00:00

Close on the heels of our first fellow, we’re now super happy to welcome our second, Matt Colyer. We’re huge fans of his smartermeter project and definitely want to see more like it for other energy providers. smartermeter’s roadmap includes carbon calculation (powered by our CM1 service) and a UI for PG&E customers.

Are you working on a project like Matt’s? Or have another idea you want to pursue? The Developer Fellowship accepts unsolicited applications, so visit the Fellowship page for details.

State of Green Business Forum Recap

2011-02-07T00:00:00+00:00

I just got back from two days at the 2011 State of Green Business Forum. Attendees included members of Fortune 500 companies, large private firms, universities, small businesses, and government agencies. The varied representation from industries was a testament to how far sustainability has come in defining 21st century business.

Standout presentations included Rob Bernard of Microsoft, who looked at the evolution of cloud computing and the potential it offers for addressing and mitigating environmental damage. He looked at current climate models, which can take a month to run and Microsoft’s work in reducing that down to days and then hours, allowing for greater analysis and more precision.

The conference highlighted a growing swath of corporate America that is keenly aware of the role that environmental and social issues play in maintaining and strengthening their bottom line. But it remains clear that this leadership alone is insufficient. Too many companies are remaining on the sidelines, awaiting more consistent price signals and a defined regulatory environment before curbing their impact and helping their customers to do the same. The policy failure on climate and energy has clearly placed business at the forefront of carbon mitigation, but the approach remains far too ad hoc to result in the kind of emission reductions needed to prevent catastrophic climate change. The state of green business is one of great innovation hamstrung by government failure.

Introducing our Developer Fellowship program: real financial support for important software projects and their developers

2011-02-01T00:00:00+00:00

We use a whole lot of open source software at Brighter Planet—Ruby, Rails, and Vagrant, just to name a few. A few months ago, we decided that we wanted to take a cue from EngineYard’s OSS Community Grant program and provide meaningful financial support to the volunteer developers of important software projects.

We’re now happy to announce the Brighter Planet Developer Fellowship.

Calling all developers: Do you maintain software critical to the GitHub-EngineYard-AWS ecosystem? Working on a scientific library for Ruby? Have an idea for a clever way to use CM1 carbon calculations? Curate an authoritative dataset? We can support and accelerate your good work. Please get in touch (#brighterplanet on Freenode, @brighterplanet on Twitter, or brighterplanet on GitHub).

We’re thrilled to welcome our first Developer Fellow, Scott Bulua. Scott’s building a plugin for TripIt that tracks the carbon footprints of users’ itineraries using calculations powered by our CM1 web service. We’ll be hearing from Scott on this blog from time to time as he develops his tool; check back for updates.

Interested? The Developer Fellowship accepts unsolicited applications, so visit the Fellowship page for details.

Climate risk management by the numbers

2011-01-18T00:00:00+00:00

As of Monday, we have performed more than 2,000,000 cloud-based calculations. After all, climate risk management is about numbers, and Brighter Planet is about delivering those numbers to you.

You can:

use your existing systems and software
reach out with XML to get results
keep the results in your own database, alongside your own data, where it will do the most good
get professional consultants to perform the integration, or use your own developers
start immediately and ping our free tech support support@brighterplanet.com (9–5 EST) when you need help.

Every organization has to build its own business case for climate intelligence. To help, we have demos, whitepapers, and real results—so far more than 2,000,000 of them.

The wonderful convenience of Earth

2011-01-13T00:00:00+00:00

When I was whipping up Yaktrak I needed to get a (richly annotated) list of zip codes into the app. This is a familiar problem for web app developers: what’s the easiest way to get auxiliary data from canonical sources loaded and ready to use?

Lucky for me we have earth. Look at how easy this is:

$ rails new zippy

In the Gemfile:

gem 'earth'
gem 'fastercsv' # only if you're on Ruby 1.8

And in config/environment.rb or an initializer:

Earth.init :locality

Back at the shell:

$ bundle install
$ rails console

1.9.3-p0 :001 > ZipCode.run_data_miner!
   (7.2ms)  DROP TABLE "zip_codes"
Receiving schema
Schema:          0% |                                          | ETA:  --:--:--
Schema:        100% |==========================================| Time: 00:00:01
Receiving indexes
Receiving data
1 tables, 200 records
zip_codes:     100% |==========================================| Time: 00:00:09
Resetting sequences
[...it will also add some related tables...]
1.9.3-p0 :002 > ZipCode.find 53703
  ZipCode Load (22.4ms)  SELECT "zip_codes".* FROM "zip_codes" WHERE "zip_codes"."name" = ? LIMIT 1  [["name", 53703]]
 => #<ZipCode name: "53703", state_postal_abbreviation: "WI", description: "Madison", latitude: "43.078646", longitude: "-89.37727", egrid_subregion_abbreviation: "MROE", climate_division_name: "WI8">

Voila! Fresh from the transparent data crawlers at data.brighterplanet.com.

Announcing our new parcel shipment model

2011-01-13T00:00:00+00:00

We just released the initial version of a new carbon model for package shipping. It’s designed to help businesses and software developers in the logistics, retail, and IT fields track carbon alongside the other parcel-level data they’re already managing in their existing software systems. You can find the press release here.

The notion that shipping packages all over the place has a significant carbon cost isn’t a new thing (although it is an increasing concern, as online shopping and business connectedness drive ongoing increases in parcel shipping volumes). UPS, FedEx, and now even the Postal Service are many years into a healthy rivalry over low-carbon transport, and some retailers have even started offering green shipping options where shoppers pay a lump sum for carbon offsets to neutralize emissions from an average package.

But considering the increasing ubiquity of parcel shipping, the scale of the resulting emissions, and the surprising accessibility of data on packages, it’s about time all the parties involved in parcel shipping – retailers, carriers, and customers – have access to quality intel on the carbon impact of individual shipments. That’s the idea behind the new parcel shipping carbon model, delivered through our cloud-based CM1 web service.

Our parcel model provides detailed, authoritative, on-demand analyses on the carbon footprints of individual packages. Whether you know details of a shipment like tracking number, weight, or shipment route, or just basics like destination, carrier, or number of parcels, the model takes the package data you feed it, uses advanced algorithms to find the ideal calculation methodology given your inputs, supplements data where needed with dynamic averages from authoritative sources, and returns an accurate CO2 figure to your system in less than a second, along with custom methodology documentation. If that sounds like a mouthful, it’s because we’ve put a lot of work into the science and tech behind this system to make our models accurate, transparent, and easy to use.

To get a feel for the new tool, check out Yaktrak, a little demo mashup we put together that shows how the parcel carbon model can be used to integrate package carbon calculation capability into websites and other web-connected applications. It lets users type in any FedEx tracking number, and it calculates the shipment’s carbon footprint in real time, displaying emissions figures for every leg of the package’s journey. Give it a try.

Shipping emissions can vary substantially according to how a parcel gets from point A to point B. Carriers have significantly different fleets of vehicles; air and ground packages are routed very differently through hub-spoke networks; and shipments of various shapes and sizes take quite different amounts of energy to transport. One size does not fit all when it comes to parcel footprints.

Using web services from Excel

2011-01-06T00:00:00+00:00

Of course it’s easy in Google Docs…

Still, I got pretty excited when I saw this for the first time:

In Google Docs, importXML lets you read XML from a web service and then use XPath to select particular elements:

=importXML(A4, "//emission_estimate/emission")

where A4 is the URL http://carbon.brighterplanet.com/flights.xml?origin_airport=MSN&destination_airport=ORD… yielding 327.4 kilos of carbon emissions or so.

What about Excel?

I first looked for an equivalent to XMLHttpRequest for Excel. A helpful StackOverflow post about Msxml2.ServerXMLHTTP and WinHttp.WinHttpRequest.5.1 got me started, but they’re Windows only. You’ll get errors about ActiveX can't create object.

Then, thanks to an excellent tip from Kennedy27, I found QueryTables:

With ActiveSheet.QueryTables.Add(Connection:="URL;http://carbon.brighterplanet.com/flights.txt", Destination:=Range("A2"))
    .PostText = "origin_airport=MSN&destination_airport=ORD"
    .RefreshStyle = xlOverwriteCells
    .SaveData = True
    .Refresh
End With

I wrote a VBA function called GetEmissionEstimate and voilà!

It took me a while to remember that Excel is essentially functional programming, so the key to getting the result to auto-refresh is to make sure the output of your VBA function is entirely dependent on the input:

Now if I change the destination airport, the emission estimate will automatically update.

Top 4 CSR trends of 2011

2011-01-05T00:00:00+00:00

Another article just went up in our sustainability experts series on FastCompany:

As we round out the first decade of the new century, business sustainability in the U.S. is coming of age. The federal carbon regulations that at this time last year seemed likely to shape the next chapter of business sustainability did not emerge, and it's now clear that the boardroom, more than the halls of congress, will be leading the charge for corporate social responsibility as we forge ahead.

An overwhelming majority of Fortune 500 companies now voluntarily measure, manage, and publicly disclose their carbon emissions; and a bevy of hi-tech software solutions, clean technologies, and market tools have evolved in recent years to meet these demands.

So what's on the horizon for the world of business sustainability management? Four key trends to keep an eye on in 2011 include…

You can see the four key trends on FastCompany.

How we replaced ParseTree in Ruby 1.9

2010-12-17T00:00:00+00:00

Like many Ruby shops, we took for granted ParseTree’s ability to show the source code of pretty much any object. As previously explained, however, ParseTree doesn’t work with Ruby 1.9.2. We fixed the problem by using sourcify.

## DOESN'T WORK IN RUBY 1.9
gem 'ParseTree', :require => false
require 'parse_tree'
require 'parse_tree_extensions'

## WORKS IN RUBY 1.9
gem 'sourcify'
gem 'ruby_parser'
gem 'file-tail'

In particular, we replaced ParseTree’s Proc#to_ruby with sourcify’s Proc#to_source.

## The old ParseTree way
proc.to_ruby
## The sourcify way - but raised NoMatchingProcError or MultipleMatchingProcsPerLineError
proc.to_source
## The sourcify way - giving :attached_to a symbol to help it find the correct Proc
proc.to_source :attached_to => :quorum

We needed to pass the :attached_to option because our carbon calculation code has multiply nested procs and we would get NoMatchingProcError or MultipleMatchingProcsPerLineError:

committee :distance do
  quorum 'from airports' do
    # [...]
  end
  quorum 'from cohort' do
    # [...]
  end
  quorum 'default' do
    # [...]
  end
end

Thanks to sourcify’s author, Ng Tze Yang, who added the :attached_to option when we showed him the problem. It made it possible to migrate our emission estimate web service, which comes with detailed carbon calculation methodology reports, to Ruby 1.9!

Reindeer, holiday carbon, and cloud computing

2010-12-16T00:00:00+00:00

Every year we send out a little holiday card to our friends. This go ‘round the Brighter Planet Christmas elves (aka Andy) emerged from the workshop with something a bit more fun and fancy than in years past, so we thought we’d share it around. It’s a little website called Claus Freight. Give it a try!

At the risk of spoiling the punchline, we should probably address some questions that have been raised regarding the carbon neutrality of reindeer. It’s been rightfully pointed out that reindeer do in fact inhale oxygen and exhale carbon dioxide. So how can they be carbon neutral? Well, the carbon they exhale comes from the plants they eat (ok so lichens aren’t quite plants, but that’s another topic), plants that quite recently pulled this carbon from the atmosphere and would shortly have released back it into the atmosphere when they died had they not been eaten. So reindeer are carbon neutral in the same way burning sustainably harvested firewood is carbon neutral—as long as the carbon you’re releasing isn’t depleting long-term reserves, you’re in the clear.

We’ve also had some inquiries about how the holiday site works. It’s powered by our new cloud-based Carbon Middleware service, which lets users outfit their applications with carbon calculation capability by plugging into our emissions models behind the scenes. This particular application employs five of the models—shipping, fuels, purchases, pets, and flights. Every time you enter your info and push go, the site computes the carbon footprint of your gift and its shipping, in real time (you can click the emissions numbers to see detailed calculation methodologies). Intriguingly, it turns out the naughtier you’ve been, the smaller your holiday footprint…

Happy Holidays to all!

Nominate Brighter Planet for the Crunchies!

2010-12-08T00:00:00+00:00

We at Brighter Planet are extremely excited about our Carbon Middleware platform that we launched this year. We believe the platform is well positioned to change the way carbon information is gathered, viewed, and assessed. The challenge for us as a small company is getting the word out in this vast sea of information that is the Internet.

Tech Crunch’s 2010 Crunchies Award is an opportunity to help us do just that. So if you like what we’ve been working on please nominate us for best CleanTech start-up of the year.

Here’s how we’re changing the game:

Carbon information - on demand and integrated. What if every time you wanted to know much fat was in your favorite snack you had to call a 1-800 number? Chances are, you probably wouldn’t spend the time. At Brighter Planet, we think that getting carbon information is just as difficult. We designed Carbon Middleware so that you could easily learn about the carbon impact of your decisions contextually, whether that be when you’re booking a flight on Kayak, sending a package with FedEx, or charging a hotel room to your credit card.
No more black box. If you enter information into ten carbon calculators, chances are you’ll get ten different scores and have no idea why. This creates a trust problem. To combat it, Brighter Planet is embracing radical transparency. Our carbon models are open source. Every calculation we provide includes methodology documentation so you can see how we derived our estimate. Finally, our models are being third-party certified so you can rest, assured we’re not just making this up.
Less than a penny. Carbon is so ubiquitous that if you have to pay a fortune to account for it, you’ll probably break the bank long before you reduce your impact. With Carbon Middleware you pay a fraction of a cent per calculation. There’s no large, upfront fee or monthly hosting cost - you just pay as you go.

Confronting climate change is difficult enough as it is. Getting information about your footprint doesn’t have to be.

So what are you waiting for? Nominate us now and please tell your friends!

Zero downtime deploys on the EngineYard AppCloud

2010-12-07T00:00:00+00:00

One of the ways we maximize our uptime is by tag-teaming two full production clusters:

Both “red” and “blue” can support 100% of our traffic, but only one of them is in charge of carbon.brighterplanet.com at a time. That way, we can make updates to the other one, test it at full production capacity, and “tag it in” when it’s ready (by changing DNS).

This is better for us than using staging environments because we’re not holding our breath for that “final” deploy to production. The tag-team approach lets us keep the old production environment running unchanged, ready to tag back in if the deploy process goes wrong.

It’s strong rollback, in the sense that all the last-known-good instances are still running (at least until we’re totally comfortable with the new ones.) It’s also graceful, in the sense that clients are not presented with a maintenance page or scheduled outage windows.

Fact: we have to store stuff offsite

If non-replicable data lived in the database master on red or blue, then we would have to export and import it every time we tagged in or out. To solve this, we make sure that all such data is stored offsite in our reference data web service, Amazon S3, hosted Mongo, etc.

Fact: we have to wait for DNS

When we switch carbon.brighterplanet.com from red to blue, we have to wait for the DNS change to propagate. If we want to roll back, we might have to wait again. As long as the old production environment worked but just had old code, this is usually OK.

Fact: we pay for more compute hours

For a while before and after any deploy, we need both red and blue at full production capacity. That costs compute hours. We think it’s worth it to avoid a single point of failure.

Fact: we rebuild from scratch more often

When we’re not preparing for a deploy, we may take red or blue down (whichever’s not “it”) to save money. When we prepare for a deploy, therefore, we need to rebuild the instances from scratch. Since we keep our build scripts up-to-date, this has not been a problem.

Github Pages, Rocco, and Rake File Tasks

2010-12-02T00:00:00+00:00

Recently, we spiffed up some of our emitters with enhanced documentation using Rocco, a Ruby port of Docco. We combined this with github’s ability to set up static html pages for a repo. By setting up a branch called gh-pages, Github will serve any html files in that branch. We use this feature to display Rocco-generated documentation of our carbon models (check out the flight emitter for an example).

This was great, but we were missing a way to automate the process by which Rocco will generate its documentation from the code in the master branch and place them in the gh-pages branch. Ryan Tomayko came to the rescue and wrote a rake task that creates a docs directory within the project and initializes a new git repository within the directory, which points to the project’s gh-pages branch. When documentation is generated, it is copied to the docs folder and pushed to gh-pages.

What intrigued me about the rake task was its use of file tasks. It’s a feature of rake I had never noticed before, but it’s pretty slick. A file task says, “if the specified path does not exist, execute the following code.” Since many unix tools use files for configuration, this feature plays well with many utilities, such as git, your favorite editor, etc.

For example, you could define a rake task that will create a .rvmrc for your project using your current RVM-installed ruby:

# Rakefile

file '.rvmrc' do |f|
  File.open(f.name, 'w') do |rvmrc|
    rvmrc.puts "rvm #{ENV['rvm_ruby_string']}"
  end
end

When you run rake .rvmrc, your .rvmrc will be generated. Try it out!

There is all kinds of magic you can work with a file task. A novel way in which Ryan’s Rocco tasks use file tasks is when deciding whether to create a git remote based on whether there is a file referencing the remote in the .git configuration directory:

# Rakefile

file '.git/refs/heads/gh-pages' => 'docs/' do |f|
  `cd docs && git branch gh-pages --track origin/gh-pages`
end

Happy raking!

Lord Stern gets stern, a.k.a. the carrot and the stick

2010-11-21T00:00:00+00:00

Economist Nicholas Stern, chair of the Grantham Research Institute on Climate Change and the Environment at the London School of Economics, and author of the 2006 Stern Review on the Economics of Climate Change commissioned by the British government, has issued a challenge to the U.S: cut emissions or face a ban on U.S. exports.

CO2 emissions per capita in the U.S.today run twice that of the European Union and almost three times that of China. Thousands of companies and millions of people in the U.S. are making efforts to cut emissions. Some are guided by the carrot of being responsible stewards of the planet. Others by the carrot of reductions in energy costs. Still others by creating a draw for customers, employees, investors, partners. All good, but not enough.

Sticks can also motivate. Sticks such as investor pressure, government regulations, or peer pressure. Now add the stick of a potential ban on exports as the U.S. treads water on emissions actions at the same time as Europe and the Far East advance even further to control emissions and transition from dirty to clean energy. These countries that have taken climate action do not want American competitors to undermine their own industries.

How odd to have the U.S. at the other end of the bargaining table. I think of the economic sanctions the U.S. undertook in the 1980’s to pressure South Africa on apartheid, which many believe lead to a multi-racial political bloodless revolution. Or more recently, of our economic sanctions against Iran aimed at limiting their use of nuclear power, with mixed results to date.

Brought on by the failure of climate regulations in Washington, I wonder whether this threat of concrete economic consequences will spur action. Now, with a massive trade deficit undermining our long-term economic vitality, the specter of a ban on U.S. exports would hit American businesses where it hurts the most: the cash register.

Our latest tool, rapid lifecycle carbon assessment

2010-11-17T00:00:00+00:00

Calculating the exact lifecycle carbon footprint of everyday goods and services is a laborious and often prohibitively expensive process. A few months ago, we set to work building a tool to help organizations get a jump start on estimating the emissions associated with the things they buy. Our goal was a flexible emissions model that could efficiently process existing data streams to calculate carbon estimates as far back through the value chain as possible for a wide spectrum of goods and services.

The result is our new purchase carbon model, released today (see the press release). It uses an advanced environmental economic input-output model to calculate a full cradle-to-consumer lifecycle carbon footprint. It works for any product or service. And it can be used automatically in a system that, for example, processes financial transaction data already present in your electronic banking records and procurement logs, giving a quick impression of the hotspots in your purchasing patterns.

To see a demo of the tool in action, check out Fedprint, a quick mashup that brings the purchase carbon model to bear on America’s largest consumer the, US federal government. Updated hourly, it spotlights the carbon footprint of the most recently awarded contracts in the Federal Purchase Data System.

For developers, the purchase model is live for experimentation and production use on Carbon Middleware. A few developer links: vehicle purchase (methodology), office supplies (in JSON), carbon model source code, API documentation

Tim Juliani joins our advisory board

2010-11-10T00:00:00+00:00

We’re excited to announce that Tim Juliani, Director of Corporate Engagement at the Pew Center on Global Climate Change, has joined our Advisory Board. We first met Tim in the summer of 2008, when he stopped by our Middlebury office to discuss carbon offsets.

Tim brings years of experience working at the crossroads of business and the environment. Amongst many of his roles, he directs the Pew Center’s Business Environmental Leadership Council, (BELC) the largest US-based association of companies devoted to climate related policy and corporate strategies. His perspective and insight will help the development and growth of Carbon Middleware.

Welcome Tim!

Open carbon code

2010-11-09T00:00:00+00:00

There’s been a flurry of commentary about opening up climate model code over the past month, mostly centered around an article in Nature back in October. The discussion really broke out into the tech blogs when John Graham-Cumming opined on the reason for all the secrecy. I’m not sure I agree with his final diagnosis—that it’s just about scientists trying to not look foolish—but his call-to-action is right on:

If everyone released code then there would be (a) an improvement in code quality and (b) an ‘all boats rise’ situation as others could build on reliable code

Here’s what we’re doing at Brighter Planet:

We release all of our carbon models as open-source code under the AGPL.
We provide custom-generated methodology documentation like this for every one of our calculations.
We’re now using Rocco to do literate-style documentation of our methodologies (example), with specific focus on compliance with standard carbon accounting protocols.

The sad truth is that if you enter the same input data into each of the hundreds of carbon calculation software packages available now, you’re going to get a different answer each time. To be fair, all science is uncertain, so this is somewhat to be expected. But with transparency—especially documentation and open-source code—at least we’ll know why.

We are an XML web service, too

2010-10-25T00:00:00+00:00

You can talk to Carbon Middleware in XML:

$ curl -v http://carbon.brighterplanet.com/automobiles.xml \
       -H 'Content-Type: application/xml' \
       -X POST \
       --data "<make>Nissan</make>"

You can receive responses in XML:

<?xml version="1.0" encoding="UTF-8"?>
<hash>
  <emission type="float">4017.7826406033573</emission>
  <emission-units>kilograms</emission-units>
  <make>
    <fuel-efficiency type="float">11.7886</fuel-efficiency>
    <fuel-efficiency-units>kilometres_per_litre</fuel-efficiency-units>
    <name>Nissan</name>
  </make>
  <!-- [...] -->
</hash>

We’re just trying to make it easy to connect with us, whether your application speaks XML, JSON, or even x-www-form-urlencoded.

New redwood forest offset project

2010-10-12T00:00:00+00:00

We’ve just added a new project to our carbon offset portfolio, the Big River and Salmon Creek forests. Comprising a combined 16,000 acres of redwood and Douglas fir forest in Northern California’s Mendocino County, these two tracts of land were recently purchased from a timber company by a consortium of conservation groups and converted to sustainable management. They represent a hopeful example of nonprofit organizations, state agencies, and private interests coming together to find creative land management solutions that maximize carbon sequestration and forest biodiversity while preserving sustainable forestry jobs and recreation opportunities. We’re pleased to play a role.

The project generates offsets by increasing forest carbon reserves. The transition from traditional logging practices to sustainable management involves halving timber extraction, harvesting trees more selectively to maintain diversity, and increasing and restoring riparian buffers along rivers. By substantially increasing the density and average size of trees, carbon dioxide is pulled from the atmosphere at higher rates into larger reserves of above- and below-ground carbon stocks.

The carbon offsets are certified under the Climate Action Registry, an offset standard that includes a rigorous set of protocols to verify the credits represent legitimate carbon reductions. One important aspect is the verification of additionality, which in this case is established by demonstrating dependency on revenue from offset sales to repay the loan taken out to purchase the land from the timber company.

In addition to clear climate benefits, the Big River and Salmon Creek project is a major boon for biodiversity and local community, which is also important under our carbon offset policy. Restored riparian buffers will improve water quality for threatened stocks of Coho salmon and steelhead trout, and increased forest cover and structural diversity offer improved habitat for Northern Spotted Owls and threatened terrestrial species. Local communities will benefit from the continued existence of sustainable tibmer jobs, as well as increased recreational access under the new management regime.

The addition of these projects to Brighter Planet’s portfolio represents a strategic diversification of our carbon offset blend, introducing sink-side forest offsets for the first time. This move was largely in response to customer demand — our most recent member survey revealed sustainable forestry as a top-ranking project type of interest alongside renewable energy. We are meeting this demand with these top-notch domestic forestry projects that verifiably reduce carbon pollution while providing key ecological and economic benefits that help to mitigate the effects of climate change.

10/10/10

2010-10-10T00:00:00+00:00

Just got back from my 10/10/10 work event: canvassing North Cambridge with free CFLs to give residents in exchange for their incandescents.

Now i’m watching reports streaming in from around the world and following the blog for some highlights. I was especially proud to see one of our Project Fund grant recipients listed as a featured U.S. project by the 350 staff.

SoCap Recap

2010-10-07T00:00:00+00:00

Ian and I just got back from SOCAP10, where Brighter Planet was the in-kind carbon offset sponsor.

SOCAP10 brings together some of the major thought leaders in the field of “social capital markets.” These are markets such as microfinance and clean technology which use the power and efficiency of market systems to solve pressing social and environmental issues.

My favorite panel was one in the Metrics/Systems thinking track that focused on creating a universal language and set of metrics to assess social and environmental impact. It asked basic questions such as “What do we mean when we say ‘green job’?” and “How do we compare one company’s social and environmental performance to another’s in a way that is similar to comparing investment ratings?” In more mature fields we take commonality of language and metrics for granted, but in emerging industries this work is elemental and essential.

I’m happy to report that two organizations are providing the framework for communicating and measuring social and environmental performance. The Global Impact Investing Network has produced IRIS (Impact Reporting & Investment Standards), a dictionary for terms describing the social and environmental performance of an organization, while B Lab’s GIIRS (Global Impact Investing Rating Systems) assesses the social and environmental impact of companies and funds using a common ratings system analogous to credit risk ratings.

This is particularly interesting and valuable to Brighter Planet because carbon is a key environmental metric that is all too often under-reported or ignored. We believe people’s understanding improves when carbon emissions are placed in context alongside other metrics, both traditional and emerging. Efforts such as IRIS and GIIRS help to shed light on what have traditionally been shadow metrics by bringing order and structure to the process.

EPA releases new guidance on emissions reporting for federal agencies

2010-10-07T00:00:00+00:00

This Tuesday the EPA released official guidance for federal agencies on measuring and reporting GHGs. The guidance serves as the government’s official GHG Protocol, outlining precisely what agencies need to measure and report to comply with Executive Order 13514.

A potential ‘surprise’ is that for Fiscal Year 2010 reporting (due January 2011) the guidance only requires Scope 3 emissions from employee business ground and air travel, employee commuting, contracted solid waste and wastewater disposal, and electricity transportation and distribution losses. Executive Order 13514 originally required agencies to also report emissions from leased buildings, the production of fuels used in agency vehicles, and vendors, contractors, and supply chains. But because Scope 3 accounting is new and “recognized methods for calculating emissions are just emerging,” these and other Scope 3 sources will be phased in over time.

Learning from Climategate

2010-10-05T00:00:00+00:00

I was honored to be invited to the annual technology-and-social-change gathering Web of Change this year, and even more excited that I was able to make a presentation.

I’m embedding the slides and a video which was kindly shot by Mr. Ian Rhett. The presentation is in Ignite style, so it’s a total of five minutes long.

Back From JRubyConf

2010-10-04T00:00:00+00:00

I just got back from JRubyConf in Columbus, Ohio. I had a great time meeting other Rubyists and learned a great deal about how Ruby is being integrated into enterprise environments via JRuby. It’s really exciting to see “the big guys” embracing a language and ecosystem that we at Brighter Planet enjoy using on a daily basis.

When I got back home, I decided this would be a good opportunity to try out our new meeting and lodging emissions models to come up with a carbon footprint for my trip to the conference.

I started out with the meeting space itself. I fired up Google Earth and measured the square footage of the conference center we were at - about 1,150 square meters. With the area of the space and the location, I came up with 3.08 tons of CO2e generated by the heating, cooling, and electricity usage of the space: methodology. Of course, if we considered my individual footprint, it would be 150th of that amount, given that 150 of us shared the space. This comes out to 0.02 tons.

I then looked at my hotel stay for two nights at the Hampton Inn and came up with 0.09 tons of CO2e: methodology. I looked up the lodging class from our data repository

To get to the conference, I carpooled with a couple other Rubyists from Ann Arbor, Michigan. I used 18 gallons of gas, which comes out to 68.1L. When we developed the automobile trip emitter I was surprised to learn from Seamus and Ian that the type of engine you have doesn’t make a significant difference in the amount of CO2 emitted, it really comes down to how much gasoline is burned. Therefore, our automobile trip emitter looks at the type of fuel and the quantity burned. Transportation to and from the conference came out to 0.18 tons of CO2e: methodology. Divided by the three of us, my personal transportation footprint was 0.06 tons.

Of course, no conference weekend is complete without a few good meals with fellow programmers. Over the course of the weekend, I mostly ate vegetarian, but I splurged on a trip to City Barbecue for a tasty beef brisket sandwich. I looked at all the food I ate, and calculated the share of each of the food groups I ate. My foodprint for the weekend was 0.02 tons of CO2e: methodology.

Overall, my total footprint was 0.19 tons of CO2e. Had I not carpooled, the biggest factor would have been the car trip to the venue. With carpooling, most of my emissions came from the hotel stay.

Over the past few years, there have been more and more regional Ruby conferences, and it’s great to see the community buzzing. I think it would be really cool if someone could whip up a web app that analyzes Ruby (or other) conference footprints, perhaps based on data gathered from attendees. We could make a competition out of it to see which conference has the best average per-attendee footprint!

Our carbon gem is now also a command-line carbon calculator

2010-10-03T00:00:00+00:00

Version 0.3.0 of the carbon gem—our Ruby wrapper for the emission estimates service API—includes “command-line access” to the web service:

# `carbon`
carbon-> key '123ABC'
  => Using key 123ABC
carbon-> flight
  => 1210.66889895298 kg CO2e
flight*> origin_airport 'lax'
  => 1461.63846640404 kg CO2e
flight*> destination_airport 'jfk'
  => 1733.79410872608 kg CO2e
flight*> url
  => http://carbon.brighterplanet.com/flights.json?origin_airport=lax&destination_airport=jfk&key=123ABC
flight*> done
  => Saved as flight #0
carbon-> exit

(Notice that you’ll need a developer key to use this or any other Carbon Middleware-powered library.)

We think this feature might be especially useful to researchers and scientists who want to make “quick” calculations but still want to rely on our rigorous, transparent carbon models.

For complete documentation see the README.

Go ahead and give it a try!

$ gem install carbon
$ carbon
carbon->

Ruby 1.9.2 Marshal.dump remembers string encoding

2010-09-30T00:00:00+00:00

Ruby 1.9.2 remembers encoding when it marshals a string:

ruby-1.9.2-p0 > Marshal.dump('hi')
 => "\x04\bI\"\ahi\x06:\x06ET" 
ruby-1.9.2-p0 > require 'iconv'
=> true 
ruby-1.9.2-p0 > Marshal.dump(Iconv.conv('US-ASCII', 'UTF8', 'hi'))
=> "\x04\bI\"\ahi\x06:\x06EF"

Ruby 1.8 did not:

ruby-1.8.7-head > Marshal.dump('hi')
 => "\004\b\"\ahi" 
ruby-1.8.7-head > require 'iconv'
 => true 
ruby-1.8.7-head > Marshal.dump(Iconv.conv('US-ASCII', 'UTF8', 'hi'))
 => "\004\b\"\ahi"

Calculating hotel emissions

2010-09-28T00:00:00+00:00

Following up on our recent release of an event module for our carbon middleware service, we’re excited to announce the release of a lodging module.

Developers can now use our API to calculate emissions from hotel energy use within their own applications. The calculations use data from the EIA’s Commercial Buildings Energy Consumption Survey and the EPA’s eGRID, which are automatically imported to our database and updated nightly to ensure currency.

Possible applications of the lodging emitter include a company calculating Scope 3 emissions from business travel, a hotel booking website calculating your stay’s emissions, a travel agent adding offsets for lodging emissions to a vacation package… but don’t let us limit your thinking!

We’re hard at work cranking out more emitters, so stay tuned for updates.

Event carbon calculation added to middleware toolkit

2010-09-22T00:00:00+00:00

For years we’ve been doing custom carbon emissions inventories for meetings and events ranging from conventions and conferences to music festivals and sporting events. Now we’ve released a new meetings module of our carbon middleware service that lets software developers build event carbon calculation into their own applications.

The meetings and events emitter, accessed through our API, lets users specify a range of characteristics to calculate emissions from venue energy use. Used in combination with other carbon middleware emitters like transport, hotel stays, food, and fuel purchases, an event inventory can be expanded to cover the desired emissions scope.

Underpinning this event carbon model are authoritative data from the EIA’s Commercial Buildings Energy Consumption Survey and the EPA’s eGRID, imported automatically to our system on a daily basis to ensure currency.

We’re excited to see website and software developers put the tools to use. We’ve got applications in mind ranging from widgets that let wedding and party planners estimate their impact, to platforms that enable corporations to manage all aspects of convention and summit carbon footprints. But IT engineers will no doubt surprise us with innovative ways to integrate this carbon data into their systems.

Events and meetings can be great opportunities not only to meet your organizations’ own sustainability goals, but also to promote conservation by helping to enlist participants and attendees in the emissions calculation and reduction process. In working with event organizers we’ve had great success using a four-pronged approach that addresses event carbon inventorying, emissions reduction initiatives, mitigation through offsetting, and attendee participation in measuring, reducing, and offsetting their own event travel emissions.

Deborah Baxley joins Brighter Planet Advisory Board

2010-09-21T00:00:00+00:00

We’re pleased to announce that financial industry veteran Deborah Baxley has joined our Advisory Board. With her wealth of experience as a strategist for companies including IBM, MasterCard, Bank of America, Visa, and American Express, Debbie’s perspective will help us grow and enhance our offerings at the intersection of financial- and carbon services.

Debbie is a Principal with Capgemini’s Financial Services Global Business Unit. Widely recognized for her insights on the future of retail payments, she has chaired the Smart Card Alliance Contactless and Mobile Payments Council, and co-chaired the 2009 Alliance Payments Council Summit. She is a frequent keynote speaker and prolific author on topics of mobile and advanced payments innovation, having authored 15 published articles and white papers.

Welcome, Debbie.

Expanding lifecycle analysis capabilities with EIO-LCA data

2010-09-10T00:00:00+00:00

We’re pleased to announce that we’ve just added the Economic Input-Output Life Cycle Assessment (EIO-LCA) model to our carbon data resources. Licensing this authoritative model further expands our ability to perform lifecycle and supply chain carbon emissions analysis.

The carbon accounting field is increasingly focusing on Scope 3 emissions, including supply chain and product lifecyle emissions. Supplier sustainability programs by institutions like Walmart, IBM, P&G, and the federal government are driven by the realization that for many organizations, embodied emissions represent the majority of total carbon impact.

The EIO-LCA model from Carnegie Melon University’s Green Design Institute combines federal Economic Census data with research on the environmental impacts of hundreds of economic sectors. It enables lifecycle assessment for all phases of production including raw materials extraction, transport, manufacturing, and retail.

Through our new partnership with CMU, Brighter Planet will provide rapid environmental impact analysis for goods and services such as electronics, food, healthcare, vehicles, consulting, entertainment, clothing, and supplies.

Finding a GOOD home for Wowcrowd

2010-09-01T00:00:00+00:00

Quick version: Wowcrowd, our web application for crowdsourced funding allocation, has been acquired by our friends at GOOD.

Now here’s the background.

We started Project Fund as our main corporate philanthropy initiative a year ago to fill a need we saw in the climate community: neighborhood-scale climate projects needed quick access to small grants, and they were willing to work hard to get them.

To make a long story short, Project Fund was a runaway success, one we’re very proud of. With 199 projects submitted and over 100,000 votes cast, we were able to give $50,000 in grants to 10 spectacular causes.

But Project Fund was also successful in another unexpected way: the “crowdsourced funding allocation” model itself was a hit, winning us a Social Innovation award from Financial Times. When the Pepsi Refresh Project launched in January, it took the concept to a totally different scale. That’s when “How could I start my own Project Fund?” became one of the most common questions we at Brighter Planet heard.

So this past winter we spun up a new Ruby on Rails app codenamed wlpf1 (“white-label Project Fund”) and started filling it with Project Fund code extracted from our main web application. A few months later Wowcrowd was born.

Recently we realized that somebody else could probably do a better job of running with Wowcrowd. After all, we’re a climate company. The very first group that came to mind was GOOD, not only because they’re friends of ours, but also because they are an active partner in the Pepsi Refresh Project and have been closely involved since its launch earlier this year. They’re also probably the world’s best folks at connecting great people with great causes.

And a handful of weeks later, the ink is dry. Here’s the press release. GOOD, she’s in your hands. We can’t wait to see where you take this.

Announcing Carbon Middleware

2010-08-13T00:00:00+00:00

Brighter Planet has been building technology for climate change since 2007, including a fully automated carbon offset provision, retirement, and assignment system (to interface with Bank of America and power our credit and debit cards) and what we feel is the world’s best carbon profiler for individuals.

We’re opening up our technology as a platform, and we can’t wait to see what can be done with these systems. Have a look at the new site and tell us what you think.

Use Amazon SQS to get emission estimates

2010-08-11T00:00:00+00:00

You can get emission estimates by queueing up messages on Amazon SQS:

$ curl -v https://queue.amazonaws.com/121562143717/cm1_production_incoming -X POST --data "Action=SendMessage&amp;Version=2009-02-01&amp;MessageBody=emitter%3Dautomobile%26make%3DNissan%26guid%3DMyFavoriteCar%26key%3D86f7e437faa5a7fce15d1ddcb9eaeaea377667b8"
* About to connect() to queue.amazonaws.com port 443 (#0)
*   Trying 72.21.211.87... connected
* Connected to queue.amazonaws.com (72.21.211.87) port 443 (#0)
  # eliding some standard server messages for brevity . . .
> POST /121562143717/cm1_production_incoming HTTP/1.1
> User-Agent: curl/7.20.0 (i386-apple-darwin9.8.0) libcurl/7.20.0 OpenSSL/0.9.8m zlib/1.2.3 libidn/1.16
> Host: queue.amazonaws.com
> Accept: */*
> Content-Length: 158
> Content-Type: application/x-www-form-urlencoded
> 
< HTTP/1.1 200 OK
< Content-Type: text/xml
< Transfer-Encoding: chunked
< Date: Wed, 11 Aug 2010 08:20:56 GMT
< Server: AWS Simple Queue Service
< 
<?xml version="1.0"?>
* Connection #0 to host queue.amazonaws.com left intact
* Closing connection #0
* SSLv3, TLS alert, Client hello (1):
<SendMessageResponse xmlns="http://queue.amazonaws.com/doc/2009-02-01/"><SendMessageResult><MD5OfMessageBody>fb29551a9e1c36dcf1b8ba624695210a</MD5OfMessageBody><MessageId>5d48a63b-5416-4d35-8bc5-65ace74f4d42</MessageId></SendMessageResult><ResponseMetadata><RequestId>a3e0d71a-9e47-493b-a92c-29b37393e899</RequestId></ResponseMetadata></SendMessageResponse>

You need to use this SQS queue: (but you don’t need an SQS account, it’s just a standard HTTP POST)

https://queue.amazonaws.com/121562143717/cm1_production_incoming

As you can see, the MessageBody is the url-encoded form of a querystring:

emitter=automobile&amp;make=Nissan&amp;guid=MyFavoriteCar&amp;key=86f7e437faa5a7fce15d1ddcb9eaeaea377667b8

Wait a minute, isn’t that an empty response body?

Correct. This is an asynchronous way of doing things. The result in JSON format will appear as soon as it is calculated (usually in a few seconds).

If you need an answer in realtime, then you should skip SQS and hit mostly the same querystring.

Why use SQS?

Depending on your environment, you may already have an excellent SQS client library. You’ll have the high availability of Amazon web services combined with competitive Brighter Planet pricing for asynchronous (rather than realtime) emission estimates.

Depending on your application, set-it-and-forget-it may be a natural fit. We’ll store the result for you in JSON format at an effectively randomized URL, which is perfect for AJAX calls that display results in a browser. In general, if you can queue up the emission estimate now and count on a JSON-enabled client to pull the results later, this is a good way to go.

How did you calculate the result URL?

Just SHA1 the string key plus guid. No salt or separators or anything, just 86f7e437faa5a7fce15d1ddcb9eaeaea377667b8MyFavoriteCar in this case.

ruby-1.8.7-head > require 'digest/sha1'
 => true 
ruby-1.8.7-head > Digest::SHA1.hexdigest('86f7e437faa5a7fce15d1ddcb9eaeaea377667b8MyFavoriteCar')
 => "745c4bcda8234186178e8430ae55f38913a5f042"

Other notes

We host the storage on Amazon S3, so you’ll benefit from high-availability there too.
If you’re using Ruby, you can use our carbon gem with the :guid option.
If you would rather have us POST the result back to your waiting servers, you can pass &callback=http%3A%2F%2Fmyserver.example.com%2Fcallback-receiver.php.

Sharing Rails views with Jekyll

2010-08-09T00:00:00+00:00

In my last post I discussed how we share a single layout between Rails apps. This has been a lifesaver for us as we manage a half-dozen production apps. But a couple of our sites—our developer hub and this here blog—don’t use Rails. They’re both Jekyll sites running on GitHub Pages.

Obviously we can’t rely on the Rails Engine features in our shared layout gem to load the layout into the right places. What are we to do?

One step at a time

Luckily Jekyll already includes the basic building blocks of our solution: layouts and includes. Layouts, described here are Liquid templates, and Jekyll ships with a custom Liquid extension that enables includes.

All we need to do then is transform our Rails layout into a Jekyll layout and use includes instead of partials. Ready, set, go.

When in Rome

Jekyll is a static site generator. Following this lead, our transformations will be manually executed and staticly stored within your Jekyll site. The easiest way to get started is to set up a task in your Rakefile:

require 'net/http'
require 'uri'
require 'erb'
require 'lib/stubs'
namespace :layout do
  task :build do
    File.open File.join(File.dirname(__FILE__), '_layouts', 'default.html'), 'w' do |f|
      f.puts ERB.new(Net::HTTP.get(URI.parse('http://github.com/brighterplanet/brighter_planet_layout/raw/master/app/views/layouts/brighter_planet.html.erb'))).result(Layout.new.get_binding  { |*pages| '{ { content } }' if pages.empty? })
    end
  end
end

What’s going on here? Rake is fetching the raw ERB of your layout from the gem’s repository, sending it to ERB for processing, and then storing the result as your Jekyll site’s default layout.

I should call your attention to a couple of tricky bits here.

Bindings

First, this business about bindings. ERB needs a “binding” to work–that is, a context within which it can access instance methods, variables, etc. Rails takes care of this for you, but since we’re invoking ERB here directly, we have to tell it where to bind. Why is this important? Your layout probably uses methods like stylesheet_link_tag or render to get its job done. If we don’t provide those methods in ERB’s context, we’ll get NoMethodError all over the place. The easiest way to fool ERB is with a fake context, which we’ll put in lib/stubs.rb:

class Layout
  def stylesheet_link_tag(*sheets)
    sheets.collect do |sheet|
      "<link rel=\"stylesheet\" type=\"text/css\" href=\"/stylesheets/#{sheet}.css\" />"
    end
  end
  
  def javascript_include_tag(*args); end
  
  def render(options = {})
    "{٪ include #{options[:partial][/[a-z_]*$/]}.html ٪}"
  end
  
  def get_binding
    binding
  end
end

You can see how we re-interpret these method calls in a way that’s meaningful to Jekyll. (Note that since binding is a private method we have to publicize it with the get_binding wrapper.)

Yields

The second tricky bit is dealing with your standard Rails layout’s multiple yield calls, the consequence of using content_for blocks in your views. We have to anticipate this and set up ERB to act accordingly. Where do we even capture arguments to yield? Turns out the correct place to do this on get_binding, our wrapper to the private binding method. Now the yield we’re interested in—the one where we want Jekyll content to go—is the one called without any arguments. So we set the block to output the content Liquid tag when it sees yield called with an empty argument set. Other yield calls—to dump content_for material, which could never be prepared by Jekyll anyways—are simply ignored.

And we’re done

Your complete layout package will probably include several partials—each with its own fake context class in stubs.rb—as well as asset files. To build your layout from its source in the cloud, just

$ rake layout:build

Check out our developer hub’s Rakefile and stubs.rb for all the details.

Bundler to the Max

2010-07-28T00:00:00+00:00

I have been spending the past few weeks creating and refactoring our carbon model gems, with the goal of making them easy to enhance, fix, and test by climate scientists and Ruby developers. I wanted to make contributing a simple process and bundler fit the bill quite well.

A not-so-widely-known feature of the Rubygems API is the ability to declare a gem’s development dependencies, along with its runtime dependencies. If one planned on making changes to one of the emitter gems and testing it, she could run gem install <emitter_gem> --development and have any needed testing gems installed for the emitter gem.

This is all fine and good, but I chose to use bundler to manage our dependencies, as it adds a few extras that have been a tremendous help to us. To contribute to any of our gems, a developer can follow a simple process:

$ git clone git://github.com/brighterplanet/<gem>.git
$ cd <gem>
$ gem install bundler --pre  # this is needed until bundler 1.0 is released
$ bundle install
$ rake

And Bob’s your uncle!

Bundler + Gemspecs

The first goodie that bundler provides is the ability to use the gem’s own gemspec to define the dependencies needed for development. For instance, our flight gem has a gemspec with dependencies:

Gem::Specification.new do |s|
  # ...
  s.add_development_dependency(%q<activerecord>, ["= 3.0.0.beta4"])
  s.add_development_dependency(%q<bundler>, [">= 1.0.0.beta.2"])
  s.add_development_dependency(%q<cucumber>, ["= 0.8.3"])
  s.add_development_dependency(%q<jeweler>, ["= 1.4.0"])
  s.add_development_dependency(%q<rake>, [">= 0"])
  s.add_development_dependency(%q<rdoc>, [">= 0"])
  s.add_development_dependency(%q<rspec>, ["= 2.0.0.beta.17"])
  s.add_development_dependency(%q<sniff>, ["= 0.0.10"])
  s.add_runtime_dependency(%q<characterizable>, ["= 0.0.12"])
  s.add_runtime_dependency(%q<data_miner>, ["= 0.5.2"])
  s.add_runtime_dependency(%q<earth>, ["= 0.0.7"])
  s.add_runtime_dependency(%q<falls_back_on>, ["= 0.0.2"])
  s.add_runtime_dependency(%q<fast_timestamp>, ["= 0.0.4"])
  s.add_runtime_dependency(%q<leap>, ["= 0.4.1"])
  s.add_runtime_dependency(%q<summary_judgement>, ["= 1.3.8"])
  s.add_runtime_dependency(%q<timeframe>, ["= 0.0.8"])
  s.add_runtime_dependency(%q<weighted_average>, ["= 0.0.4"])
  # ...
end

Instead of defining these dependencies in both flight.gemspec and in Gemfile, we can instead give the following directive in our Gemfile:

gemspec :path => '.'

Bundler + Paths

We have a chain of gem dependencies, where an emitter gem depends on the sniff gem for development, which in turn depends on the earth gem for data models. In the olden days (like, 4 months ago) if I made a change to sniff, I would have to rebuild the gem and reinstall it. With bundler, I can simply tell my emitter gem to use a path to my local sniff repo as the gem source:

gem 'sniff', :path => '../sniff'

Now, any changes I make to sniff instantly appear in the emitter gem!

I had to add some special logic (a hack, if you will) to my gemspec definition for this to work, because the above gem statement in my Gemfile would conflict with the dependency listed in my gemspec (remember, I’m using my gemspec to tell bundler what gems I need). To get around this, I added an if clause to my gemspec definition that checks for an environment variable. If this variable exists, the gemspec will not request the gem and bundler will instead use my custom gem requirement that uses a local path:

# Rakefile  (we use jeweler to generate our gemspecs)
Jeweler::Tasks.new do |gem|
  # ...
  gem.add_development_dependency 'sniff', '=0.0.10' unless ENV['LOCAL_SNIFF']
  # ...
end

# Gemfile
gem 'sniff', :path => ENV['LOCAL_SNIFF'] if ENV['LOCAL_SNIFF']

So now, if I want to make some changes to the sniff gem and test them out in my emitter, I do:

$ cd sniff
  # work work work
$ cd ../[emitter]
$ export LOCAL_SNIFF=~/sniff
$ rake gemspec
$ bundle update
  # ...
sniff (0.0.13) using path /Users/dkastner/sniff
  # ...

And then Bob is my uncle.

Bundler + Rakefile

This next idea has some drawbacks in terms of code cleanliness, but I think it offers a good way to point contributers in the right direction. One thing that frustrated me about Jeweler was that if I wanted to contribute to a gem, my typical work flow went like:

$ cd [project]
  # work work work
$ rake test
LoadError: No such file: 'jeweler'
$ gem install jeweler
$ rake test
LoadError: No such file: 'shoulda'
  # etc etc

I attempted to simplify this process, so a new developer who doesn’t read the README should be able to just do:

$ cd [emitter]
  # work work work
$ rake test
You need to `gem install bundler` and then run `bundle install` to run rake tasks
$ gem install bundler
$ bundle install
$ rake test
All tests pass!

I achieved this by adding the following code to the top of the Rakefile:

require 'rubygems'
begin
  require 'bundler'
  Bundler.setup
rescue LoadError
  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
end

This was convenient, but it created a chicken and egg problem: in order to generate a gemspec for the first time, bundler needed to know which dependencies it needed, which meant that it needed the gemspec, which is generated by the Rakefile, which requires bundler, which requires the gemspec, etc. etc. I overcame this problem by allowing an override:

require 'rubygems'
unless ENV['NOBUNDLE']
  begin
    require 'bundler'
    Bundler.setup
  rescue LoadError
    puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
  end
end

So, if you’re really desparate, you can run rake test NOBUNDLE=true

More on Local Gems

Now that I had a way to easily tell bundler to use an actual gem or a local repo holding the gem, I wanted a way to quickly “flip the switch.” I wrote up a quick function in my ~/.bash_profile:

function mod_devgem() {
  var="LOCAL_`echo $2 | tr 'a-z' 'A-Z'`"

  if [ "$1" == "disable" ]
  then
    echo "unset $var"
    unset $var
  else
    dir=${3:-"~/$2"}
    echo "export $var=$dir"
    export $var=$dir
  fi
}

function devgems () {
  # Usage: devgems [enable|disable] [gemname]
  cmd=${1:-"enable"}

  if [ "$1" == "list" ]
  then
    env | grep LOCAL
    return
  fi

  if [ -z $2 ]
  then
    mod_devgem $cmd characterizable
    mod_devgem $cmd cohort_scope
    mod_devgem $cmd falls_back_on
    mod_devgem $cmd leap
    mod_devgem $cmd loose_tight_dictionary
    mod_devgem $cmd sniff
    mod_devgem $cmd data_miner
    mod_devgem $cmd earth
  else
    mod_devgem $cmd $2
  fi
}

This gives me a few commands:

$ devgems enable sniff
  # sets LOCAL_SNIFF=~/sniff
$ devgems disable sniff
  # clears LOCAL_SNIFF
$ devgems list
  # lists each LOCAL_ environment variable

I now have a well-oiled gem development machine!

Overall, after a few frustrations with bundler, I’m now quite happy with it, especially the power and convenience it gives me in developing gems.

I’m really interested to hear any of your thoughts on this. Drop me a line at @dkastner.

Sharing views across Rails 3 apps

2010-07-26T00:00:00+00:00

Here at Brighter Planet we run several production Rails 3 apps, including the emission estimates service, the climate data service, and our keyserver. As the person reponsible for much of our recent front-end work, I wasn’t really looking forward to maintaining a half-dozen different versions of what is mostly the same layout. I wanted to DRY the situation up. What I really wanted was to put all the shared stuff into a gem that I could require from all of our apps that would just sort of insinuate itself into all the right places.

Luckily Rails 3 makes this possible, after a fashion. The key trick is giving your plugin a Railtie, which isn’t documented very well yet–this gist from Jose Valim is the best I could find.

To get started just add a file in lib/gemname/ called railtie.rb and require it from the main gemname.rb file:

module BrighterPlanetLayout
  class Railtie < Rails::Railtie
  end
end

Because it inherits from Rails::Railtie, you don’t have to “declare” the Railtie–Rails automatically keeps track of it and calls the right parts when they’re needed.

The easy part is telling Rails to add your gem’s view path to the app’s view path:

module BrighterPlanetLayout
  class Railtie < Rails::Railtie
    initializer 'brighter_planet_layout.add_paths' do |app|
      app.paths.app.views.push BrighterPlanetLayout.view_path
    end
  end
end

Telling ApplicationController to use the layout in your gem’s view path as the default is a little tricker–you have to use a to_prepare block:

module BrighterPlanetLayout
  class Railtie < Rails::Railtie
    # ...
    config.to_prepare do
      ApplicationController.layout 'brighter_planet'
    end
  end
end

It turns out the hardest part is hooking Rails up to your gem’s static asset files–stylesheets, images, fonts, etc. For that we add another instance of ActionDispatch::Static to the Rack middleware stack:

module BrighterPlanetLayout
  class Railtie < Rails::Railtie
    config.app_middleware.use '::ActionDispatch::Static', BrighterPlanetLayout.public_path
    # ...
  end
end

This is a fine solution in the development environment, but it’s too slow for production–your webserver has to fire up Rails just to push an image binary, for example. So in production we just copy static files to the app’s public dir:

module BrighterPlanetLayout
  class Railtie < Rails::Railtie
    if BrighterPlanetLayout.serve_static_files_using_rack? # "if in development environment"
      config.app_middleware.use '::ActionDispatch::Static', BrighterPlanetLayout.public_path
    end
    initializer 'brighter_planet_layout.copy_static_files_to_web_server_document_root' do
      if BrighterPlanetLayout.copy_static_files? # "if in production"
        BrighterPlanetLayout.copy_static_files_to_web_server_document_root
      end
    end
    # ...
  end
end

And that’s it. Check out the gem source for details on the folder structure and for additional tricks like loading shared helpers. Next time: how to use this shared layout with Jekyll.

Real code examples in our integration guide

2010-07-23T00:00:00+00:00

I realize that not everybody uses Ruby/Rails, so integration with our emission estimate web service won’t always be facilitated by our sharp little carbon gem.

Still, if I were a third-party developer, there is nothing I would want more than unfiltered code examples from a real integration, no matter the language.

Therefore I present our unfinished integration guide, complete with real diffs.

Relaunching the blog

2010-07-23T00:00:00+00:00

We’ve been hosting our own blog for a couple of years now on a custom Wordpress installation, dealing from time to time with all the idiosyncracies of a PHP application. As part of the process of launching our developer ecosystem, we thought we’d take the opportunity to transition to a more convenient, reliable approach.

After looking at a gazillion options (seriously, where are the blogging platforms that support syntax highlighting out of the box?), we settled on jekyll, which we’re already using for our Developer Hub. We’re hosting this using GitHub Pages, so deploys are as simple as

$ git push

Anyways, expect to see a greater focus on the technology behind Brighter Planet here on the new blog. Here we go!

Empowering 350.orgâs Climate Action Fund

2010-07-20T00:00:00+00:00

In the latest chapter of our perennial partnership with 350.org, Brighter Planet will provide the technology and underwriting to make 350’s crowdsourced Project Funds for Climate Action a reality.

Last fall, 350.org organized what CNN called “the most widespread day of political action in the planet’s history,” inspiring more than 5,000 events in 181 countries as part of the International Day of Climate Action. They continue to push the issue of climate change to forefront, inspiring a much needed sense of urgency in the fight to prevent catastrophic global change. Their slogan for this year, “Get to Work,” encourages grassroots action around the world, challenging people to step up and be the drivers of change in their communities, forcing our leaders to take action. In conjunction with 1010global.org, which has already signed close to 80,000 people since January in demanding a 10% annual reduction in carbon emissions, 350.org has put forth 10/10/10 as a global day of action.

Beginning today and leading up to the 10/10/10 Work Parties, 350.org will give out eight $1000 microgrants every month through their 350 Project Funds for Climate Action, funding Work Party projects that raise awareness about climate change, promote renewable energy, and show clearly that progress is possible.

Like Brighter Planet’s Project Fund, the 350 Project Funds for Climate Action will powered by our new wowcrowd platform, and the contest structure will be similar. Anybody can submit project proposals, anybody can vote on their favorite ideas, and each month the project with the most votes will be awarded a grant. Project ideas range from organized tree plantings to retrofitting buildings with more efficient CFL’s to setting up bike repair workshops.

As part of our partnership with 350.org, we’ve donated this month’s Project Fund grant money to the 350 Project Climate Action Fund. You can do your part as well—we encourage you to cast your ballots to help determine the winners, and to submit your climate project ideas to the fund. And as 10/10/10 approaches, you can also participate in helping make 350 ppm a reality by joining a local Work Party or registering your own. With your help, thousands of communities will come together to make 10/10 the biggest day of practical action to cut carbon the world has ever seen.

–the Brighter Planet team

Case Foundation's Wowcrowd interview

2010-07-01T00:00:00+00:00

Last week, our friends at The Case Foundation sat down with Brighter Planet’s Robbie Adler to talk about the release of our new crowdsourcing technology platform Wowcrowd:

Josh: Thanks again for speaking to us today Robbie. Just to clarify for all of those who might be a bit confused, what exactly is Wowcrowd?

Robbie: Wowcrowd is a social web application that gives organizations the tools to crowdsource the allocation of funds, which helps them engage their stakeholders and surface bright ideas.

The concept is simple. An organization with a Wowcrowd account earmarks a pool of money for a particular mission, and then opens the process to their users—their employees, members, customers, constituents, or the general public. Individual users submit proposed ideas for how the funding could be spent, and then all the users vote to decide which of the proposals will get funded and be realized.

Josh: What are the benefits of challenges and contests like the ones being run on Wowcrowd?

Robbie: A well-run crowdsourced program can provide some very important benefits for an organization. It opens a slice of the decision-making process to their stakeholders, which engages them as active participants in the organization’s mission rather than as passive donors or members—and an engaged constituent base clearly offers many advantages.

It can also be a strong PR tool, because as we’ve learned, contest participants (including proposal submitters and voters) end up devoting their own energy and effort to spreading the word in support of their cause, effectively creating brand ambassadors for the organization. Administered through an online tool like Wowcrowd, these programs can be easily integrated with other social media channels to efficiently promote the fund and the organization.

Of course, another big benefit is the crowdsourced ideas themselves. By tapping into the collective intelligence of their stakeholders, a contest administrator can efficiently surface creative ideas that are diverse and compelling—ideas they likely wouldn’t have thought of themselves.

You’ll find the full interview, conducted by Joshua Tabb, on the Case Foundation blog.

Established in 1997 by Jean and Steve Case, the Case Foundation utilizes a citizen-centered approach to encourage civic engagement in the U.S. and around the Globe. The organization focuses on the “big-swing-for-the-fences ideas” with large potential for change to achieve their mission: “invest in people and ideas that can change the world.” Recently they conducted the America’s Giving Challenge, a one month competition to unite people around the issues they care about, increase awareness for the issues, and attract donors. The challenge was enormously successful, bringing in over 105,000 donations and raising $2.1 million for various nonprofit causes.

Emissions modeling methodology published

2010-06-29T00:00:00+00:00

The field of carbon emissions modeling is in a period of rapid evolution, shaped by ongoing transformations in climate science, information technology, government regulation, and the business environment. Demand for data about the impacts of carbon-emitting activities is steadily increasing— but so too are the complexity, opacity, and inconsistency of emissions calculation methodologies, undermining advancements in the field.

At a time when carbon intelligence has an urgent role to play in stemming catastrophic climate change, a more deliberate approach to carbon modeling is warranted. Reactive attempts by authorities to establish consistent, transparent methodology standards have been only marginally successful, more so in the sphere of corporate carbon footprinting than elsewhere. As a small company developing carbon emissions models, Brighter Planet is committed to doing our part in helping transform this field.

In developing our modeling approach, we were guided by three core principles: rigor, flexibility, and transparency. We knew that our system would need to provide high quality estimates that accounted for an emitter’s full and complete climate impact. We knew that the model would need to operate given huge real-world variability in the quantity and quality of data available about emissions sources. And we knew that radical openness and collaboration would be critical to maintaining trust and quality in a rapidly evolving space at the intersection of multiple fields.

Our goal for this methodology paper was to provide insight into the approach and data that we use to model greenhouse gas emissions, both to help fulfill our commitment to openness by documenting our own practices, and to foster a discussion about best practices in carbon modeling to help advance the field. We welcome discussion and collaboration on this project!

–The Brighter Planet Team

200 million pounds!

2010-06-10T00:00:00+00:00

201,938,091 pounds of carbon dioxide pollution that never was.

As of today that’s the greenhouse gas emissions that you, the Brighter Planet community, have prevented from being released. More than 150,000 individuals and businesses have come together to support the construction of 19 community renewable energy projects (and counting). These wind turbines and cow power facilities at schools and family farms across the country generate clean electricity and prove the viability of new energy technologies, create green jobs and economic opportunity in rural America, and reduce the environmental and social burdens of fossil fuel use, coal mining, and methane pollution.

The greenhouse gas emissions you’ve prevented so far is equivalent to:

4,000,000,000 party balloons filled with carbon dioxide -- two for every child on earth
6,600,000 cars removed from the road for a day
23,700,000 tree saplings sequestering carbon for a year
480 railroad cars full of coal never burned
3 full days of every US home turning off all their lights

Thanks everybody for doing your part to prove that working together using innovative tools, we can make a very real difference!

2010 on track for record high temps

2010-05-19T00:00:00+00:00

It’s that time of the month again – the week when NOAA scientists release last month’s “combined global surface temperature” data – and we’ve got yet another winner. It was the warmest April on record, hot on the tail of the warmest March.

The March and April heat was more than enough to pull the entire four-month January–April average into record territory, despite January and February having been merely the fourth- and sixth-warmest on record.

Yes, you’re reading that correctly: the North American Arctic has been about 9 DEGREES FARENHEIGHT (5 C) warmer than average these last four months. Yikes.

Expect to see more of the same as we move into the rest of 2010: NASA researchers predict the trend to continue, forecasting that 2010 will weigh in as warmest year in recorded history.

The effects? Well for one, warmer sea surface temperatures are a key element in predictions by folks at CSU, NCSU, and Accuweather that the 2010 Atlantic hurricane season (which opens on June 1) will be significantly more active than average and “has the chance to be an extreme season.” Critics have called the Gulf oil spill “Obama’s Katrina”, but chances appear better than average he’ll get a literal Katrina of his own.

–Matthew

Update: Greensburg dedication ceremony

2010-05-07T00:00:00+00:00

This past Friday, the town of Greensburg, Kansas held an official dedication for their new wind farm. We’d like to share some photos and video from our partner NativeEnergy.

As Steve Maller, Program Manager for John Deere Renewables, said at the ceremony, “the Greensburg wind farm provides a vivid example of how local leaders, governments and private industry can collaborate to develop renewable energy projects that help sustain Americas’ rural communities and our rural heritage.”

Thanks again to all our members. You’ve made this project possible.

-Ian

GOOD infographic: Household Carbon Emissions and What You Can Do

2010-04-23T00:00:00+00:00

This Earth Day our friends at GOOD asked for our help illustrating household emissions and tips for reducing them. We shared some data, and they produced this beautiful infographic:

TreeHugger's "Best of Green" awards hit home

2010-04-09T00:00:00+00:00

TreeHugger has just announced the “Best of Green” awards. And we’re proud and thrilled to see that Brighter Planet has taken the cake for Small Business of the Year!

The work we do here is fairly diverse, so it’s nice when somebody captures it succinctly. TreeHugger’s summary observed:

“Offering credit and debit cards and carbon offsets, funding several small-scale renewable energy projects such as methane digesters and farmer-owned wind turbines, and also doing some interesting carbon reporting – most recently one on the carbon footprint of food which clarified some important aspects of the impact of food miles – Brighter Planet’s products, projects and services stood out this year.”

Many of our friends and allies were recognized in the Best of Green awards as well. Congrats for your well-deserved wins:

Bill McKibben (member of our advisory board), named Best Political Amabassador
Our partners at 1% for the Planet, named Best Non-Profit Partnership
Our partners as 350.org, named Best Climate Activism
The folks at Greenbiz, named Best Business Website
Climate Progress, a favorite blog of ours, named Best Politics Website
Gavin Newsom of San Francisco (which we now call home in concert with Vermont), named Best Mayor

Upcoming SF event: panel discussion on employee sustainability

2010-03-29T00:00:00+00:00

We’re pleased to announce that Brighter Planet is partnering with San Francisco Carbon Collaborative to host a lively event in our newest home, San Francisco! If you’re on the west coast, come join us on Wednesday, April 14 for a high-level panel discussion that will examine findings from our recently published report on employee engagement in corporate sustainability. We’ll hand the conversation to our panelists, who will share their experiences, strategies, and best practices in an interactive forum. It will be a great opportunity to learn from companies who are leading the charge in incorporating employees (and their ideas!) into a sustainability strategy. And yes, there will be drink. Hope you can make it! See the details below…

Brighter Planet Presents New Employee Engagement Report: Wednesday, April 14, 2010 at 111 Minna Gallery, San Francisco 6:00pm – 7:30pm, immediately followed by Climatini ———-———- ———-———-

Employee Engagement is becoming an increasingly popular means to drive corporate sustainability efforts. Around the world, companies and communities are mobilizing their workforces to lessen pollution, waste and operational inefficiencies. However, a new analysis by Brighter Planet suggests that employees are generally dissatisfied with their employers’ sustainability initiatives. Moreover, many employers are unable to quantify the effects of their internal efforts. This finding is especially timely in light of increasing executive pressure to measure the impact of sustainability work on bottom line.

Please join the San Francisco Carbon Collaborative, Brighter Planet, and Climatini on April 14th, for a panel discussion and an exploration of how to better foster Employee Engagement in the sustainability arena. We’ll preview the new Brighter Planet study and consider the following:

How can companies enhance CSR strategies by fusing employee initiative and forward green thinking?
How does the strategy of sustainable employee engagement ft within the larger theme of CSR?
How can we measure CSR/EE impacts upon triple bottom lines?
What are the pros and cons of implementing top-down vs. bottom-up sustainability programs?
How should companies incentivize employee-led initiatives?
Where are the cutting-edge opportunities and best-practice ideas?

This event is free of charge with a cash bar. Space is limited, so please register by clicking here.

Patti Prairie, CEO, Brighter Planet: Brighter Planet provides technology-driven climate change solutions that help people and businesses manage their environmental impact.

Andrew Bryson, Senior Director, Saatchi & Saatchi S: Saatchi S is a leader in sustainability consulting, having successfully designed and implemented employee engagement programs for some of the world’s largest corporations.

Lisa Carpenter, Director of Strategy and Communications for Social and Environmental Responsibility, Gap, Inc.: Gap is a pioneer in the areas of CSR & environmental sustainability, having successfully reduced the social and environmental impacts of their business operations in four key areas: supply chain, environment, employees and community investment.

Ellen Lee, HR Director, Sun, Light & Power: Sun Light & Power is a small solar power integrator based in Berkeley, CA. The company’s culture is built on a commitment to employee engagement that extends the environmental benefit of their core business.

Moderator – David Pascal, President, San Francisco Carbon Collaborative: David is co-founder of the SF Carbon Collaborative and was most recently the Clean Tech and Green Business Advocate for the City and County of San Francisco.

Brighter Planet wins 2010 Social Innovation Award!

2010-03-25T00:00:00+00:00

At a dinner in NYC last night, I learned that we won the 2010 Financial Times & Justmeans Social Innovation Award for most strategic philanthropy program!

The Project Fund, our community-powered monthly grant program for grassroots climate projects, has gone viral. The idea is simple: anybody can submit a grant proposal, and anybody can vote to decide which project will win the grant. Our goal in launching it six months ago was to help communities that lack access to seed money turn their good ideas into real-world solutions to climate change.

As I told the audience at the Hudson Theatre when I accepted the award, the recognition by the Financial Times, Justmeans, and the distinguished panel of judges is a tribute to the 150,000 Brighter Planet customers who endow the Project Fund, to the 100 projects submitted over the past six months, and to the tens of thousands of voters across the nation. And, of course, to our Project Fund grantees which range from post-coal sustainability projects in Appalachia, to youth activism in Copenhagen, to tree planting in Wisconsin.

It’s so satisfying to be able to jump-start deserving projects like these. So now we’re providing this crowd-sourced philanthropy technology to other businesses, campaigns, foundations, and non-profits. Our social giving platform, wowcrowd (in private beta but live soon!), lets organizations engage their members to propose, discuss, and vote on ideas to receive project funding.

Thank you to the Financial Times, Justmeans, and the panel of judges for your recognition.

–Patti

Update: clean energy flowing in Greensburg!

2010-03-15T00:00:00+00:00

The answer may be blowin’ in the wind, but it’s not always easy to find. For Greensburg, Kansas, it took a devastating natural disaster, a visionary commitment by residents, an arduous fund raising effort, and a lengthy planning and building process, to get the clean energy flowing. But that day is finally here.

Leveled in 2007 by a EF-5 tornado that destroyed more than 95% of the buildings in this town of 1500 residents, Greensburg vowed to rebuild as the greenest town in America. Now, less than three years later, that commitment has paid off as the first of ten massive new wind turbines begin to spin outside town.

The Greensburg Wind Farm by NativeEnergy came online this month, and we’re thrilled that members of the Brighter Planet community were able to play a key role in making this story a reality. As charter supporters of this wind farm, every Brighter Planet cardholder helped fund its construction every time you swiped your card to buy gas and groceries. Thanks everybody! It’s great to see another inspiring example of innovative ways we can come together to build a clean energy future.

The ten turbines, each capable of producing up to 1.25 MW of electricity, will provide enough clean energy to power the town several times over – this allows Brighter Planet members who contributed to the project to claim rights to some of the clean energy produced, with enough left over for the town of Greensburg also to claim carbon neutrality.

The sheer scale of these turbines is awesome; each one is as tall as a 35-story building, with blades a long as the wingspan of a Boeing 747. An eyesore for local residents? Quite the contrary – the only concerns raised during the placement process came from folks who wanted the project located where it could be seen from their homes.

Employee sustainability survey results: the good, the bad, the ugly

2010-02-10T00:00:00+00:00

We’ve finally wrapped up the crunching, sifting, charting, and interpreting of the 30,000+ datapoints collected in our recent online survey about the employee engagement practices of US employers. Thanks to all of you who took the time to respond to the survey questions. Today we released the report that details our findings.

Mindy Lubber, president of Ceres (and Brighter Planet advisory board member), signed onto the cause with her contribution of the foreword. As she says, “This report from Brighter Planet both provides a benchmark for the status of employee sustainability programs in the US as they continue to evolve, and helps to inform their development by highlighting factors that contribute to their success. We look forward to watching employee engagement initiatives play an increasing role in helping our institutions to overcome the challenges of our time.”

Here are a few of the findings at a glance. Download the complete report to get the full results and insights.

Most employers have only just begun interacting with employees around sustainability, and their efforts leave room for improvement. Although 86% of respondents said their organization promotes employee sustainability in some arena, only 16% said their employer collects data related to employee sustainability and just 14% said their employer had an official employee sustainability engagement policy.
Small organizations are leading on employee sustainability engagement. Organizations with fewer than 100 people are nearly twice as likely to promote sustainability very frequently, and their efforts are twice as likely to be effective at changing employee behavior.
The most effective engagement programs feature an organization’s management or board as the main advocate for employee sustainability. These programs are three times as effective as those in which an employee sustainability director was the main advocate.
Employees are generally dissatisfied with their employers’ sustainability engagement efforts. Over 60% of respondents want to learn more about their employers’ and co-workers’ sustainability efforts, and 67% would like their employers to change their stance on sustainability.

–Matthew

Eat your way to a healthy climate: new report

2010-01-29T00:00:00+00:00

Wanted to share with you all a white paper that we just put out, entitled “The American Carbon Foodprint: Understanding and Reducing your Food’s Impact on Climate Change”. Using the emissions model that we built to power the footprint calculator on this website, we analyzed the cradle to grave climate impacts of the average diet, and pulled the results together in a report that explains and interprets them. It turned up some pretty enlightening (and sometimes rather surprising) stuff – good background for anybody who is into understanding the food they eat.

A few highlights:

The average American’s carbon “foodprint” is 6.1 tons of CO2e a year. That’s bigger than the combined impact of all their driving and flying.
Production accounts for close to half of a meal’s total climate impact, and red meat is by far the most potent emitter of all the food groups.
Of all the transportation emissions associated with your food, less than a tenth result from delivering food from the producer to the vendor, while more than two thirds result from your own driving to grocery stores and restaurants. That puts the importance of “food miles” in perspective!
Kitchen energy accounts for 29% of a meal’s life cycle impact. Cooking at home is far more carbon-efficient than eating in restaurants.

Yes, the climate impact of our dining habits is substantial. But it’s pretty straightforward for each of us to make changes that significantly reduce those impacts. We distilled the learnings into seven take-home tips:

Eat fewer animals and more plants
Buy unprocessed foods with less packaging
Grow and harvest your own food
Minimize car trips to restaurants and stores
Cook at home more and eat out less
Cook with efficient appliances and techniques
Compost, recycle, and relish leftovers

Check out the full paper to get answers to all the carbon foodprint questions you never knew you had, and let us know what you think.

–Matthew

Fly green, for real

2010-01-14T00:00:00+00:00

In a recent post on Fast Company, we ranked the major US airlines by climate impact per passenger.

We started with data from the Bureau of Transportation Statistics’ T-100 database, a collection of monthly reports from every airline that is certified to fly in the US. We took factors like flight distance, aircraft model, number of passengers, and amount of freight carried, combined them with aircraft fuel use equations from the European Environment Agency, and ran the lot through our emissions engine. (Fun fact: the calculations took about 15 minutes on a standard household computer.)

This chart shows the complete ranking, from best to worst in pounds of CO₂e per passenger-mile.

Note: a passenger-mile is one passenger flying one mile.

-Ian

Geeking out with carbon footprint calculations: the foodprint of EatingWell holiday recipes

2009-12-18T00:00:00+00:00

Sometimes we really geek out with carbon emissions calculations at Brighter Planet. We crunch numbers down to the thousandth decimal in order to make recommendations about what is better to buy/do/eat in terms of one’s carbon footprint. In light of our Sustainable Cooking Contest(which runs two more weeks through December 31st!) and the stories we’ve received about reducing impact in the kitchen, we’re going to break down some fantastic holiday recipes from EatingWell for you.

Here are the general estimates for the carbon footprint of these recipes, measured in lbs. of C02e.

Horseradish crusted beef tenderloinand Vermont Cheddar Mashed Yukon Golds:

Total- 56 lbs CO2e, or 7 lbs per serving.

Beef kcal/serving- 220 servings- 8
lbs co2e- 34.5
lbs co2e/serving- 4.3

Potatoes kcal/serving- 223
servings- 8
lbs co2e- 21.5
lbs co2e/serving- 2.7

Roasted Fall Vegetables in Cheddar Crust and Green and Yellow Beans with Wild Mushrooms:

Total- 38 lbs CO2e, or 4.6 lbs. per serving.

Vegetable Pie
kcal/serving- 378
servings- 8
lbs co2e- 29.8
lbs/serving- 3.7

Beans/Mushrooms
kcal/serving- 75
servings- 10
lbs co2e- 8.3
lbs/serving- 0.8

Choose the veggie-based dishes and you’ll have over 30% reduction in CO2e. This shows how replacing a few meaty holiday dishes with non-meat dishes, or choosing poultry and fish over red meats, can shave off a significant chunk of your “foodprint.” The other thing to keep in mind is that 11% of food emissions comes from transportation, so buying locally-sourced produce can decrease total food-miles from dirt to plate and reduce the total emissions.

If you want to do some more estimating and playing around with food emissions, check out the Food section of our Footprint Calculator.

-Carolyn

Add your pets to your carbon footprint!

2009-11-17T00:00:00+00:00

Ok folks, the day you’ve been eagerly awaiting has finally arrived. We’ve just turned on a new module in the footprint calculator that gives personalized pet emissions estimates – so go ahead and add your pets!

Believe it or not, pets actually do cause a sizable quantity of greenhouse gas emissions. The AVMA puts the number of dogs and cats in the US at over 150 million, plus tens of millions more horses, birds, and small animals; that’s a lot of mouths to feed. The vast majority of your pet’s climate impact comes from producing, transporting, and distributing its food, although we also figure in its share of the emissions from veterinary offices.

The average dog weighs in at about 2 tons of CO2 a year while the average cat emits about 1000 pounds, making the typical American citizen’s pet footprint about 1.8 tons per year (yes, I’m talking about people-years here). Of course, your pet footprint varies greatly depending on the number of pets you own and their species and size. As always, the calculator begins by assuming you own an average number of average pets, and incrementally adjusts that estimate as you provide more personalized info on your own pets.

Having pets does cause emissions, but there are plenty of things you can do to reduce that impact – having your animals fixed, being conscious about the ingredients and packaging in your pet food, and avoiding extraneous pet accessories all make a big difference. You can even join others in building renewable energy projects to offset your furry friend’s climate impact – that’ll really make her beam in adulation.

Oh and FYI, we’ll be working to add many more new functions (think recycling, hotels, entertainment, motorcycles, clothing, health care, rental cars…) to the footprint calculator as time goes on, so stay tuned.

–Matt K

Imperfect Planning and the Best Keys

2009-11-11T00:00:00+00:00

I recently received some requests from BlenderNation to write a little about how to animate a bumblebee. Toward this goal I can’t help but think about the unpredictability of planning a project under deadline and the importance of keyframing by hand.

First, the planning. I could lie and talk about what an ideal planner I am. I could draw up fake storyboards and draft a fake script to make it look as though I intended every choice of this project from the start as though some twist of genius granted me direct connection to a god-like inspiration. But it doesn’t work that way, not on any project that I’ve known.

Given this, one might surmise that my idea of planning is to shoot from the hip and hope for the best. But that isn’t it either. That suggests that planning is irrelevant; that good work can come from reckless behavior. Maybe it can to some people, but not to me, and never under deadline.

The projects I have taken the time to plan have all succeeded to some degree or another. The projects I have failed to plan have failed themselves. But for the ones that worked, there was always a plan.

Paradoxically, the plan, however good, has always changed at some point between the beginning of production and the end. For example this bumblebee project began without a single bumblebee. It was supposed to be about flowers. I happily started the script, imagining how the beautiful sun would shine its nourishing light on various plants until their seeds fell down to the soil to grow into a garden.

Then I set to work on a concise voice-over narration script with lots of puns and active verbs. I sketched out a couple storyboard drawings of the plants, their seeds swelling and dropping. Everything was going according to plan. But as I opened up Blender to begin modeling something inside of me groaned.

The work was boring. I had seven shots of seven plants relishing in the sunlight and growing their seeds. After modeling just one I was sick already of the plants and the sunshine and the glory of nature. My heart sank and I began to look for ways to jettison the entire project without causing too much collateral damage.

This is when the bee flew in to land on the back of my pollen clogged brain, and when he did everything about the plan changed. Now there was a protagonist, the glimmer of a story, and an idea worth planning for.

But before charging through the steps that carry any animation project from beginning to end – write, storyboard, model, rig, animate, etc. – I counted the days I had remaining: Ten days till deadline. With that number in my head I planned a film that I could produce in five. In the end it took me twelve.

Now keyframing. For those unfamiliar with the animation term, each keyframe is an image that the animator creates to bring meaning to a film. Every keyframe in a finished film is necessary. Like the keystone in an arch, if a single keyframe goes missing the whole piece can collapse.

In 3D computer animation keyframes are an opportunity for human touch. Keyframes take time to build for they must be made one by one by hand. The amount of labor it takes to keyframe an animation has turned away many interested people from the field. It’s just too much work. In the days of classical hand-drawn animation this labor seemed well understood. However, 3D computer animation suffers a myth that animation with the help of a enough computers can be easy. If we could only build the perfect rig, or hire enough helpers or program the perfect animation software then animation could be effortless.

But if that day ever comes when all one must do is push the animate button and pull the emotion lever to somewhere between happy and sad, then animation will be finished, no longer interesting.

Take the challenge away from the animators and the viewers will find no joy in watching what they make. For me it is awe that I experience when I witness animation far greater than my own. It drives me to improve and allows me to appreciate how far I’ve come. I am not a great animator by any means, but I know now that animation is worth the effort.

3D computer animation is a powerful, sophisticated, precise tool. But it is only a tool. It is not the art. It is not the artist. My older brother Michael said to me recently, “I’ve given up on the ability of computers to solve the problems of the world.” He went on to suggest that a computer is like a bulldozer. A bulldozer is very good at pushing dirt around. Bulldozers have come a long way since their ancestor, the rake. A modern bulldozer is capable of pushing so much dirt around so quickly it boggles the mind. But a bulldozer is only beautiful so long as all you need is dirt. Anything more requires a human being.

This is the keyframe, that thing that only a single human being can do, that moment of communication between author and audience, the image that makes all your effort into more that a hill of dirt.

So please, pour all of your energy into those keyframes, all of it. Your keyframes decide the success of the piece; the rest will follow.

In the movie Gattaca, two brothers race by swimming straight out to sea. The loser is whoever turns back first. Always the same brother loses, the one not biologically designed for super-human strength. Over and over growing up they race until one day the weaker brother wins. The stronger cannot fathom how. “This is how I did it, Anton: I never saved anything for the swim back.”

If you have never worked on an animation yourself then to stumble upon someone else’s work-in-progress can be baffling. The computer monitor becomes a portal into some strange three-dimensional world constantly orbiting a pale gray character wrapped in wire. The unfinished character stares vacantly forward, its arms out stiffly to the sides as though recently crucified. Even more baffling to the onlooker is how the animator, back hunched, fingers clicking rapidly at the keyboard and mouse, seems not to mind the gruesome monster and even thinks it handsome.

It is a work in progress. It does not yet communicate anything to the outside world, but it will. All that is missing are the keyframes. Those are the life of the piece. Once they are in place the arch stands up without support. The bridge is built. Communication flows.

So that’s how you animate a bee! I would imagine that solving climate change has an equally logical answer. If you discover what this answer is, please let me know. In the meantime I’ll be working at it myself, hoping another bee lands on my brain.

-Daniel

Behind the Scenes of the Project Fund Video

2009-11-02T00:00:00+00:00

Check out our latest video made with the wonderful Blender animation software.

Download the behind the scenes files!

This project began with a script about plants, which turned into a storyboard of pencil sketches, plants, flowers, seeds of all kinds swelling and dropping from their branches. These sketches evolved into a collection of 3d models, and rigs and everything seemed to be going according to plan.

Then a bee flew into the room and landed near my desk. It’s wings slowed from a blur to rest on its back. When the little guy looked up at me everything changed. I threw out the script and the storyboard. I shut down my animation software and started over with pencil and paper to tell the story of the bee.

Voting for this month’s projects began yesterday and closes on the 15th, so vote today!

-Daniel

Breaking ground in Greensburg

2009-10-23T00:00:00+00:00

Today is a big day in Greensburg, Kansas. This morning is the official groundbreaking on the Greensburg Wind Farm by NativeEnergy, the most recent offset project funded by Brighter Planet members. The project has been years in the planning, but with construction beginning today the ten 1.25 Mw turbines are set to be operational by this coming spring. They’ll generate enough clean electricity to power the 4,000 homes in the community several times over, and prevent the release of more than a billion pounds of CO2 over twenty years.

Brighter Planet is excited to stand by other charter supporters in making this project a reality, including Ben & Jerry’s, Clif Bar, Stonyfield Farm, and Green Mountain Coffee Roasters. And we’re also excited to give individuals the opportunity to invest in this project through both and creative channels, like applying their credit card reward points to help bring the project to life.

Discovery Chanel’s Planet Green is set to film the groundbreaking, as they have many other events in their inspiring series chronicling the rebuilding of Greensburg from tornado disaster zone to model green town. We’ll share that video here as soon as it becomes available.

–Matt K

First Project Fund grant goes to Sustainable Energy and Economic Diversification project to promote green jobs

2009-10-21T00:00:00+00:00

We’re pleased to announce that Andrew Munn from Rock Creek, West Virginia is the first recipient of a Project Fund grant. His project, Sustainable Energy and Economic Diversification (SEED) in the Coal River Valley, will receive $5,000 to get a kick-start on fighting climate change. With the support of Coal River Mountain Watch, SEED will reduce local dependency on coal extraction and help educate young students and workers on alternative forms of employment. Over two weeks, the project garnered a whopping total of 4,731 votes.

The October voting period showcased eighteen project proposals and brought in a total of 13,983 votes from across the country. Other top project submissions included an effort from Green Light New Orleans to install CFL light bulbs in low and middle income communities, and a project from the Burlington Food Council in Vermont to fund a staff position to promote local food networks.

This is just the first step in Brighter Planet’s grassroots stimulus package for the climate. Six new grassroots submissions from California, Texas, West Virginia, Indiana, and New Hampshire have already been vetted and are on deck. Voting will begin again on November 1^st, so be sure to come back and make your voice count!

-Matt V

Curious where the votes came from? This map shows votes for the top five projects.

âMastering the Art of Sustainable Cookingâ Contest

2009-09-23T00:00:00+00:00

The idea is simple–share your own experiences reducing your “foodprint,” learn how others are making great food that’s also good for the planet, and win some killer prizes!

These days, it’s hard to miss the hubub about electric cars and fluorescent lights, wind turbines and cash for clunkers. But it might come as a surprise to learn that in terms of carbon emissions, the impact of the food you eat is on par with the car you drive and the home you inhabit. This contest is all about raising that awareness, sharing great ways we can each reduce the climate impact of our diets.

Here’s how it works. Just browse through the cooking conservation tips, and submit stories and photos of how you reduce your impact for each category you’re interested in. As you’re poking around, be sure to give a nod to other experiences you like—at the end of the contest, stories with the most “thumbs up” will be rated against the judging criteria.

Culinary and conservation heavyweights on our judging panel include chef and local food pioneer Alice Waters, author and journalist Bill McKibben, and Stonyfield Farms CEO Gary Hirshberg.

Yes, there is loot to be won: random prizes throughout the contest, and top prizes of Amazon Kindle DXs in each category. The top experiences will be published online, and broadcast here on our blog. And just as importantly, you’ll learn about ways make delicious, low-impact meals, and inspire others to do the same!

Join us at the main contest page!

–the Brighter Planet team

Climate bill benefit at least double the cost.

2009-09-16T00:00:00+00:00

Everyone talks about the costs of climate legislation. Opponents distort the numbers to make it seem too costly while supporters point out that cutting greenhouse gas emissions will be pretty cheap. But the cost is only half the story – what about the benefit?

It’s hard to monetize the benefits of avoiding climate change. But as Grist reported, a federal interagency task force has been hard at work and they recently released an interim estimate of the ‘social cost of carbon’ - the cost of inaction. They peg this at $19 per metric tonne of CO₂.

What does this mean for pending climate legislation? An NYU law school paper (summarized here) applied the interim estimate to the Waxman-Markey American Clean Energy and Security Act. They found it would create $1.5 trillion in benefits, more than twice the EPA-estimated cost of $660 billion. Strengthening the bill to reduce more emissions would only improve the cost/benefit ratio.

Now factor in that the EPA says their cost estimate is almost certainly too high while the interagency task force says their benefit estimate is almost certainly too low (it leaves out things like the impacts of weather variability on agriculture, threats to national security, ocean acidification and coral reef death, and the spread of infectious diseases).

The upshot may have already been obvious to all of us who think it’s worthwhile to avoid catastrophic climate change. But it’s nice to have some numbers to throw around when you say passing strong climate legislation is the investment opportunity of an era.

-Ian

Behind the Scenes of âYour Planet, Brighterâ

2009-09-15T00:00:00+00:00

If you’d like to explore more about how this movie was made, download the project file and explore it with Blender’s magnificent animation software.

Announcing the Brighter Planet Project Fund to seed grassroots climate projects

2009-09-15T00:00:00+00:00

Over the past few years, we have been continually inspired by the thousands of individuals and community organizations growing the climate movement from the ground up. We’re thrilled to announce a new monthly micro-grant fund, the Brighter Planet Project Fund, to provide motivated Americans with seed money for projects that help people fight and adapt to climate change.

As you know we spend quite a bit of time here fussing with our projects—the wind turbines and methane digesters that produce the offsets you earn with our cards. But this fund is about your projects: the neighborhood-scale solutions like weatherization and education that might not produce offsets but are nevertheless critically important to the planet. Think of it like a grassroots stimulus package for the climate.

One of the things we’re proudest of is that the fund is endowed by our members. Every time you use one of our cards or purchase an offset package from us, a percentage of our revenue gets deposited automatically into the fund. This means that as the Brighter Planet community grows, we’ll be able to do more and more good.

Know a local school that could use some insulated windows? Maybe your church wants to put a solar panel on its roof? Want to invite a climate leader to speak at your library? You guys have the ideas; let’s make them happen.

-the Brighter Planet team

Think the Volt is greener than the Prius? Think again.

2009-08-25T00:00:00+00:00

GM recently announced fuel economy figures for the plug-in hybrid Chevy Volt: a whopping 230 miles per gallon! Using the same EPA standards, a rival automaker, Nissan, reported that their all-electric Leaf would get 367 mpg.

Mind-blowing numbers, right? You would think the Volt or the Leaf will blow the 50 mpg Prius off the road. Not true in half of the country. The long and short of it is driving 100 miles in a Prius emits 40 lbs of CO₂e across all states whereas driving 100 miles in a Volt in Kansas emits 53 lbs, in California 19 lbs, and in Massachusetts 25 lbs. When electricity comes from burning coal, the Prius is hands-down greener than charging your Volt from the garage outlet.

While we applaud products that reduce our dependence on foreign oil, it’s time to put the greenwashing brakes on the spin that electric cars are the environmentally friendliest throughout the land. Just because you can’t see the fossil fuels being burned to make electricity doesn’t mean they’re not being burned when you’re on a dirty grid. Let’s put the pedal to the metal on a new renewable energy infrastructure. Then plug-in hybrids and electric cars will be greener than ever.

-Rich + Ian

For this comparison we used:

2010 Toyota Prius – 50 miles per gallon
Chevrolet Volt – 25 kWh per 100 miles (running on electric only)
Gasoline emissions – 19.777 lbs CO2e / gallon (based on US EPA GHG Inventory)
Electricity emissions – year 2005 data from eGRID2007 v1.1

Tame your carbon footprint with the new brighterplanet.com

2009-08-14T00:00:00+00:00

We turned on our new website for real this week. w00t! WAHOO!! YEE-HAWW!!! (Beg pardon — that little celebration has been more than a year in coming.)

The new brighterplanet.com is a free, fun, and easy-to-use web utility that will help you succeed in living a more planet-friendly lifestyle, in the same way that other online tools help people get a handle on their finances or adopt a diet/fitness regimen. All you need to get rolling is a desire to be part of the solution to environmental challenges. We’ll show you — and help you show others — how personal choices add up, how to get started, and where to pick off low-hanging fruit.

Feedback from early-bird users was immensely helpful in refining the app through our beta period. And (now that we’ve danced our little jig, kinda like these guys), it’s back to work. We’ll continue to shape brighterplanet.com based on your feedback, and we’re not planning to rest for a long while. There’s lots to do:

Twitter integration. Soon you'll be able to link your twitter account to your Brighter Planet profile. This will give you easy access to sharing your experience with your friends.
Facebook integration. Facebook connect is coming soon. You'll be able to interact with your facebook friends right from the Brighter Planet website.
Widgets and badges that can be embedded virtually anywhere.
Share your Brighter Planet activity anywhere via a custom RSS feed.
Carbon profiler precision: soon you'll be able to tell us how much waste you generate, and how much of it is recycled. You'll also be able to calculate your pet's emissions!
Carbon profiler UX enhancements: we're constantly working on new ways to make entering information easier.
Compare your footprint to others on Brighter Planet.
More third-party integration. We're all set to start doing data handshakes with some of the big get-things-done services (spots where you pay your bills, do some shopping, make travel plans, etc).
Historical data / visualizations. Set conservation goals and track your progress over time.

What’s missing from this list? What new feature (or change to an existing one) would make you the most excited?

Leave your thoughts here, or on our GetSatisfaction.com support site. Talk to us on Twitter, or Facebook. Wait… What?! You’re not signed up yet?!! Good grief, there’s no time for delay — get thee to the registration page!!

- Ian and Adam @ Brighter Planet

Behind the Scenes of Big Feet, Little Planet

2009-08-10T00:00:00+00:00

There has been some interest in how the video Big Feet, Little Planet was made. Here is a breakdown of the workflow.

Big Feet, Little Planet from Brighter Planet on Vimeo.

I was trying to visualize the idea of people stepping onto a scale and finding out the weight of their carbon footprint, so I spent a couple of hours designing a sheet of glass that I could film from beneath which would safely support a full grown human standing on top.

There were a couple of problems with this approach. It required more money to build a safe and sturdy structure than I was willing to spend. And it would result in a shot looking straight up into someone’s crotch.

Thankfully my colleague Mike had the genius idea of turning the equation on its side. “Why not have people lay down on the floor and put their feet up against a window?” he suggested. This solved the safety issue and the crotch issue, so I grabbed an old storm window from my basement and we were off.

We filmed in three environments: an abstract/hi-tech space, an office space, and a home/outdoor space. The first two feet were mens’ feet, the final one was a woman’s. I’m not sure if you can tell a person’s sex just by looking at their feet, but you can definitely tell how hairy a person’s legs are and I wanted at least one nice smooth leg.

All three shots were filmed on location, so we set up the storm window, set up the lights or the bounce cards and got a couple takes. It was surprisingly difficult for the models to hit their mark on the glass quickly and accurately. They could hit the mark if they went slowly, but it was often too slow to work for the shot. However once their foot was already on the glass they could pull it down out of frame no problem. So I ended up reversing the footage on two of the shots. In the finished piece it looks like they’re putting their foot up, in real life they are taking it down.

With the shots in place I opened up Blender, a fantastic and free animation suite and modeled the effects.

If you are curious to look deeper into the process, here are the production files.

If you’ve never used Blender feel free to download it. You’ll need it in order to explore the files above.

Once you’ve got Blender installed, just double click on a file to open it. Then tap your left or right arrow keys to step through the animation frame by frame.

-Daniel

Sneak peek: the single biggest report on the future of the planet, ever

2009-07-13T00:00:00+00:00

An important 6,700-page report (don’t worry, I’m about to summarize it for you) is coming down the pipeline. Written by world leaders and drawing on contributions from 2,700 experts from around the globe, this report will be the single biggest report considering the future of planet when it is officially published next month.

The 2009 State of the Future report, obtained by The Independent on Sunday, is backed by a diverse range of leading organizations such as Unesco, the World Bank, the U.S. Army and the Rockefeller Foundation.

The bad, but probably not surprising news, is first: the findings about climate change are grim.

Half the world could face violence and unrest due to severe unemployment combined with scarce water, food and energy supplies and the cumulative effects of climate change.
“The scope and scale of the future effects of climate change – ranging from changes in weather patterns to loss of livelihoods and disappearing states – has unprecedented implications for political and social stability.” In conclusion, climate change “will cause civilization to collapse.”

But, there are still some hopeful perspectives. The authors suggest the threats may end up being catalysts for positive change. “The good news is that the global financial crisis and climate change planning may be helping humanity to move from its often selfish, self-centered adolescence to a more globally responsible adulthood… Many perceive the current economic disaster as an opportunity to invest in the next generation of greener technologies, to rethink economic and development assumptions, and to put the world on course for a better future.”

And it is timely for us at Brighter Planet that the report also praises the web, as we consider ourselves a web-based climate change company. The web is singled-out as, “the most powerful force for globalization, democratization, economic growth, and education in history.”

Alongside from the positive force of the web, Jerome Glenn, director of the Millennium Project and one of the report’s authors, offered some concrete suggestions for a better future. “Three great transitions would help both the world economy and its natural environment– to shift as much as possible from freshwater agriculture to saltwater agriculture; produce healthier meat without the need to grow animals; and replace gasoline cars with electric cars.”

And, of course, to get to the place we need to be, there will have to be strong global agreements. “This is not only important for the environment; it is also a strategy to increase the likelihood of international peace. Without some agreement, it will be difficult to get the kind of global coherence needed to address climate change seriously.”

Here’s to positive forces, global agreements, and the future.

-Carolyn

Why Iâm psyched about Brighter Planetâs web app (part 1)

2009-06-24T00:00:00+00:00

My name’s Ian Wilker; I’ve been on the Brighter Planet bandwagon for a couple months now, serving as your friendly neighborhood community manager. (Or “community advocate,” ”unmarketer,” ”pinko marketer,” Love Boat–style “social director” … I’m here to help Brighter Planet listen to, talk with, and in the end be responsive to our online user community.

I could have offered up a “Hello world” post here some time ago, but I’m kind of glad I waited – we’ve released the beta version of our new web service, and I’m rarin’ to get out into worlds online and off to talk about it and get a good feedback loop rolling. Now I can get into the nitty-gritty, into the reasons the prospect of joining Brighter Planet made me feel all tingly.

I grew up in rural Vermont, and my parents got me and brother Josh out into the woods at every opportunity, through all seasons. It wasn’t until much later, as a city-dwelling young adult, that I realized what a gift I’d been given by all that camping, backpacking, fishing, skiing, and so on. I started getting back out into the mountains at every opportunity; there’s just no place I feel more alive than in the woods, soaking in the infinitely rich sights, smells, sounds, textures of the natural world.

Over time, through stints as a book editor and then as a web nerd, I gravitated toward jobs that brought my abiding interest in the natural world into the work. I’ve done online-communications work for a large environmental organization for going on nine years. And again and again over that time, I’ve puzzled over the problem of how to show more people that doing the right thing by the environment is rarely hard – it’s just different from what most of us are used to. It’s about examining a lot of habitual behavior, and tweaking those behaviors when there’s a more planet-friendly way to get something done.

And anyone can learn new habits – IF one goes about it in the right way. It’s process and practice that we get tangled up in. At least that’s how I’m built, it seems: give me a cut-and-dried blueprint of exactly what I want to do a little differently in a given situation, and I’m a lot more likely to start making the change. Give me a way to track the fruits of choosing a new option at a given decision point – or to see, plain as day, the stagnancy of not doing that new option, and I’ll be much more likely to really commit to the change.

We’re still building it out, but this is exactly what this next-generation of Brighter Planet will give me:

What to do next time I’m (buying some fruit; taking a shower; running the dishwasher – on and on, ad infinitum)
What making that more-sustainable choice actually does to my overall footprint – e.g. immediate feedback on the consequences of a given behavior.

Ain’t that cool? And even better: That’s just for starters. There’s a lot more to come, as I’ll explain soon in Part II of this series.

Test-drive our new site! (And expect âMen at Workâ signs.)

2009-06-19T00:00:00+00:00

At 2pm on Wednesday, June 17, we opened the doors of Brighter Planet v2.0 to beta testers.

We’ve put our all into this. Risked life and limb, I tell you – courted eyestrain, sleep deprivation, carpal tunnel, general crabbiness. Picture, then, the huge gust of giddy elation that blew through the team when the site went live and didn’t break the entire interwebs! W00t!! Jigs were danced, rafters swung from … I believe the web developers actually emptied the Gatorade jug onto the head of our CTO, Adam.

All this went on for about 10 minutes, and then deep breaths were taken and we all got back to work. We turned on the lights with our to-do list still measured in tonnage – and intentionally so. The reason? We know that you, our eagle-eyed and creative beta testers, will think of things we’d never dream up in a million years – you’ll identify software bugs, solve design problems, and suggest new features that we’re not able to see from our swimming-in-the-soup perspective. We’ll wind up with a smarter, more usable, and ultimately more useful set of tools with you all involved in decisions about where to go from here.

Great feedback has been rolling in from wonderful beta testers like Sarah and Karen. (We can’t thank you guys enough, and are all ears for whatever additional observations you may come up with.) We hope all ye who read this will give the application a whirl and get involved in the dialogue!

Meanwhile, there are crews at work everywhere on the beta site – it’s the web-application equivalent of a skyscraper construction site in there. There are functions that aren’t working quite right, that aren’t yet explained well (blame me – I’m the guy who does most of the ‘splainin’ about how things work), and that simply aren’t ripe. Here’s a round-up of high-priority problems we’ll solve asap and sorely needed features we’re committed to releasing in the near future:

What's Broke:

STUFF WE’RE FIXING IN THE “YOUR FOOTPRINT” CALCULATOR: Our new calculator is the heart of the application, and we’re proud of it – when it’s finished, we’re pretty sure it’ll be the most user-friendly, empowering personal footprint calculator out there. We mean to help you do a complete accounting of your lifestyle’s climate impact, just as the best money-management and weight-management tools help you take inventory in those areas of your life. After you’ve made a good dent in filling it out, you’ll have – cha-ching! – a complete, cruising-altitude view of all you do that has an impact, showing you where there’s real room for improvement, and allowing you to register your accomplishments and track your progress toward a lighter footstep.

So that’s our target for the calculator. At present there are both major and minor things needing fixin’:

Top priority is resolving our suspicion that the calculator is sometimes outputting inaccurate overall footprints – user feedback and our own observations suggest that some calculations are skewing too high. The calculator’s underlying fundamentals are rock-solid but some data-caching problems we’ve been experiencing could be throwing off the web application’s tabulations. Our credibility depends on providing accurate footprint estimates, and our science and tech teams are working hard on this.
Also high on the list: bad sums – breakdowns by percentage may not add up to 100; the value displayed for your overall footprint may not match what you get doing your own math adding up the values displayed for your four footprint “components” (Transportation, Shelter, Consumables, Shared Services; etc. Again, data caching issues may be causing the hinky tabulations.
Another one: say you tell the calculator you drive a Saturn. Next question posed will be “Select your car’s model” – but the list of models you’re asked to choose from are Toyotas, not Saturns. Suspected cause? You guessed it – data caching issues.
Unwieldy, unalphabetized pulldown lists: “select the airport your flight departed from,” for example. We’re implementing something that will make these much easier to use.
Opting out of a particular footprint element, e.g. “I don’t [own a car; own a dishwasher; take ferry trips, etc]”: It’s been reported that crossing off one of these isn’t always causing your footprint to be revised downward – it should, and we’re investigating. (Also, please excuse the sometimes truly inelegant phrasing of these – our favorite is “I never occupy residences.”

OTHER STUFF WE’RE FIXIN’:

A grab-bag:

browser compatibility: We’re trying to resolve some minor weirdness occuring when viewing the site in Safari and Internet Explorer 8. (Note: for now at least, we’re not supporting IE6. We’ll revisit if site traffic suggests that we should.)
Design ickyness: Throughout the application, some of the forms look fugly, as do some pages in the Carbon Offsets section, and (according to one user) the homepage itself (yipe!). They work (or should, anyway), but aren’t yet pretty. Some just need to be styled properly and we’re confident you’ll like their looks; others – hey, we’ll consider all suggestions; keep ‘em coming.
In Conservation Tips, clicking “I Did This” is still sometimes producing errors. Most likely, this is happening simply because someone’s doing some work that throws off performance until they’re finished, but we’re investigating.

What’s Coming:

Once these goodies are in place, we’re confident your experience of the site will be slick and fun indeed:

More depth and granularity in the calculator, especially in the Consumables area. This is a critical one: The goods and services Americans consume are the source of a huge chunk of our individual carbon footprints – and most carbon calculators just sidestep this part of the picture. We want our accounting to consider ALL the lifecycle climate impacts of a person’s lifestyle. My understanding is that while there’s solid data about one’s overall consumables footprint, we’ve got some work to do yet in sourcing and baking into the calculator data about consumables that allows for the same sort of thorough inventory of habits and choices that you’ll experience with, for example, the Transportation-footprint calculator. That’s where we’re headed, for sure, and you’ll see more detail here going forward.
Analytics / visualizations. Also critical – we want to provide graphs and other visualizations that give you an at-a-glance handle on what’s creating your footprint, how your footprint ranks compared to national (and global) averages, what sort of progress you’re making, and where the low-hanging fruit lies. Just for starters.
Transparent methodology. Every page of the calculator will allow you to peak under the hood and see what our data sources are and how the calculations are being done.
More robust privacy options. You’ll be able to decide, in a granular way, what information about yourself and your footprint you want to share with everyone, with just your friends, or with no one.

There are many more, but that’s the short list. Want to leave lots of breathing room for your own ideas to form – if you’re not doing so already, please sign up as a beta tester and start filing feedback if you like!

"Caveat emptor," says GOOD Magazine re carbon offsets. And we agree.

2009-06-11T00:00:00+00:00

It’s all web-app, all the time here at Brighter Planet world headquarters—we’re totally immersed in making our soon-to-be-unwrapped rebuilt website as good as it can be before we open it up to early birds.

But I did take a few minutes today to catch up on reading, and now I’m carving out a few more to talk about GOOD Magazine’s recent post on carbon offsets. Writer Ben Jervey has served up a guide for anyone who’s thinking about purchasing carbon offsets, and it’s good stuff. His sage advice is “buyer beware,” and he goes on to name names of some offset providers who are trustworthy and one that, in his opinion, is not.

In my experience, Jervey’s caution is on target. Real carbon offsets are a legit way to neutralize your remaining carbon impact once you’ve reduced your emissions as much as possible. But there are “rip-offsets” for sale out there as well, and buying them is a terrific way to get nothing for something.

How to tell the good from the bad?

As we’ve looked at projects to add to our portfolio over the last 18 months, we’ve subjected each to intense scrutiny. Those selected to date have been the best of the best from NativeEnergy, cited in GOOD’s piece as one of three trusted sellers. The piece also pulls some good questions for buyers to ask, from a report by Clean Air-Cool Planet, our partner on retiring carbon offsets once they’ve been used.

Here’s how we do it at Brighter Planet:

Brighter Planet earns the trust of our 100,000 customers by providing practical education about their lifestyle’s impact on climate and helping them find ways to reduce it.
We make it easy for our customers to offset their remaining impact by supporting real, additional, transparent projects that help local communities and the environment.
We meticulously review every project to ensure it meets our carbon offset policy and only accept those that are unanimously approved by the highly respected luminaries who sit on our project selection committee.
We work with Clean Air-Cool Planet, a non-profit organization, to ensure that every offset we sell is permanently retired and can’t be double-sold.
Finally, we subject all our processes to an annual third-party audit to make sure we’ve done what we said we were going to do.

In this still-maturing business, a company’s values – its commitment to using the best available science, to complete accountability, to transparent process, to simply doing things the right way – are of paramount importance. We know our offsets are on solid ground, and we’ve made sure to implement systems to keep it that way.

Offsets alone clearly aren’t enough to tackle climate change, but they can be an important part of the solution by funding much-needed renewable energy projects. Ultimately, offsets fulfill their potential when they’re held to high standards.

–Ian Hough, science guy @ Brighter Planet

p.s. - Ben Jervey’s a good friend of ours; he might be characterized as a James Brown of environmental journalists – the “hardest working man in the [green news] business.” We’ve no idea how he manages to write for GOOD, HuffPo Green, and his own SustainNYC; manages and writes for Greenlight, a citizen-journalism project from NRDC’s OnEarth Magazine; co-founds start-up web enterprises; and writes books. With an overflowing schedule like that, we’ll give him a pass for not including Brighter Planet in his carbon-offsets piece – even though he’s rocking our 350 Challenge badge (and thus earning offsets!) on SustainNYC. ;-)

More Farmer-Owned Wind Power!

2009-05-27T00:00:00+00:00

We’ve added five new farmer-owned distributed wind turbines to our project portfolio! By helping fund the purchase of these turbines, Brighter Planet members are reducing emissions, contributing to a more stable electricity grid, and supporting family farms.

New turbines

Original turbines

Brighter Planet's 2009 Sustainability Report

2009-05-20T00:00:00+00:00

Brighter Planet is dedicated to engaging people in the fight against climate change. From the individual to the Fortune 500 company, we believe that all must participate vigorously in the development of a more sustainable future. The world faces unprecedented challenges in the 21st century, from global climate change and biodiversity loss to resource depletion and mounting population pressures. Never before has the need for reduced environmental impact and socially responsible corporate actions been of greater necessity. We recognize we are a small player in the business world, but nonetheless we seek to be a global leader in sustainable business practices.

We do not believe in the either-or proposition of environmental and social benefit versus profit. In fact, we strongly believe that our initial commitment to environmental integrity and social quality was instrumental in our ability to attract talented employees, develop close relationships with climate leaders, select reputable partners, and begin to build a customer base.

In conducting this sustainability report we are establishing a baseline for our environmental and social performance. In keeping with our core principle of transparency we will make this document public and will actively seek feedback from all of our stakeholders.

As this report demonstrates, we still have a long way to go in reducing our impact and strengthening our social commitments. We know the challenge and pressures to live up to our sustainable principles will only grow as we grow. Nonetheless, we remain undaunted and as committed as ever to these principles. Let this report serve as our benchmark for evaluating our future performance, while helping to guide our growth.

Please see the full color report here.

We welcome your comments and suggestions.

Sincerely, Patti Prairie, CEO

Making a real, permanent difference

2009-04-08T00:00:00+00:00

Congratulations to Brighter Planet members – you shut down a dirty, coal-fired power plant for a week!

And you did it not by waving signs and shouting “No!,” but by saying “Yes!” to finding better answers to the problem of how to meet our energy, economic, and environmental needs.

Your actions as Brighter Planet members as of December 31, 2008, allowed us to transfer 67,342 tons of carbon offsets to Clean Air - Cool Planet for retirement – roughly the equivalent of a week’s emissions from that outdated, dirty power plant.

If you’re reading this and are not yet a part of our program, let me explain: Our members earn high-quality offsets with the Brighter Planet Visa credit and debit cards, and they can also buy Planet Shares to counteract their carbon emissions.

How do they know they’re making a real, permanent difference? Our policies and practices of additionality at the front-end, retirement at the back end, and transparency throughout …that’s how. We only invest in projects that meet our rigorous carbon offset policy and survive the expert scrutiny of our Project Selection Committee. None of our projects would have been built were it not for the prospect of incentives from the sale of offsets.

Offsets are legal property rights. The rights to the 67,342 tons we transferred to Clean Air - Cool Planet come from the fifteen offset projects shown in the pie chart below. Clean Air - Cool Planet is a science-based, non-partisan non-profit dedicated solely to finding and promoting solutions to global warming. They will hold these offsets in perpetuity to ensure they can never be sold or used again. That’s how our and our members’ objective of fighting climate change by reducing net emissions is achieved.

Patti

Announcing #earthtweet

2009-03-31T00:00:00+00:00

We just launched #earthtweet, a campaign to raise awareness of the fight against climate change in the days leading up to Earth Day (April 22) – and beyond.

Here’s the idea: #earthtweet uses Twitter – the booming social network of the moment – to bring together tips, news, information about events, and anything else that’s relevant to solving our climate problem. (Yeah, most of us here at Brighter Planet have caught the Twitter bug – it’s the most useful, vibrant, and fun social network we’ve seen to date.)

If you’re already on Twitter, all you have to do is tell us what you are doing – today – for the planet. Just make sure to use the tag #earthtweet somewhere in each item you’re sharing on Twitter, so everyone else can find it. We’ll also be giving away some eco-friendly prizes throughout the campaign, so follow @earthtweet to stay posted.

If you’re not yet among the converted, this is a perfect opportunity to give Twitter a try. Twitter is like CB radio, but for text messaging – it’s a great way to stay connected to friends, family, and as many other people as you like. Sign up and then you can “follow” @earthtweet and @brighterplanet!

In the last few months we’ve seen people achieve amazing things through collective effort on Twitter. Some examples:

Two months ago, a group called charity: water issued through Twitter a call for help raising awareness and funds to bring clean drinking water to some of the poorest people in the world. The twitter community responded, organizing fundraisers in more than 200 cities around the world and raising a quarter million dollars for the cause.
Last Christmas, a TVA coal-burning power plant spilled millions of gallons of toxic coal ash into an East Tennessee river. Advocates on the ground – with support from Twitter folks all over the country – used Twitter to report on the immense scale of the disaster. The buzz grew loud enough that the sluggish national media finally began to cover the story; since then, the Obama administration has made clean-up of thousands of dangerous coal-ash ponds all over the nation part of its agenda.
PowerShift09 organizers and attendees used Twitter to serve notice that young people are energized and out in force, working to drive the nation toward a clean energy economy.

Well, we want some of that action! We really hope that #earthtweet can make some noise about doing one’s part to solve the climate problem. It’s really up to all of you – #earthtweet will go exactly as far as you take it.

Have a ball with it. You’ll find badges, a widget, and temporary Twitter avatars available at http://earthtweet.com.

-Ian W.

Carbon Offsets Survey Results

2009-02-06T00:00:00+00:00

With our inaugural year under our belt, we did a customer survey. Respondents split almost evenly between male and female, with 55% under the age of 35.

Our online community has continued to grow through our social media campaigns. We asked customers about how they use the web: almost everyone uses Google, 3 out of 4 use Facebook, and while most people had heard of Twitter, only 20% use it.

Top answers to 'rate the following factors in your decision to take steps at Brighter Planet' were combating climate change, offsetting my carbon footprint, investing in community-based climate solutions, and trustworthiness of Brighter Planet.

When asked "how green do you consider yourself," 3 out of 4 responded that they embrace sustainability in their daily life and recycle, walk, take public transportation, and use CFLs. Less than a quarter live the greenest lifestyle, defined as driving a hybrid car, composting, and buying local. The remainder consider themselves light green and do a little but are not focused on it.

What was most important in evaluating offset projects? Benefits to public health and water quality were highest. A close second was verification by an independent third party. Rated less important were diversity of project types and additionality of offsets produced.

Answers to 'rate offset projects from high to low interest' yielded wind turbines and solar* installation projects tied for the top ranked spot. Almost three quarters of respondents prefer offsets from certified international wind projects to uncertified domestic projects.

Thanks to everyone who took the time to fill out our survey. Your feedback helps us improve our business. *While we are highly interested in solar offset projects, solar is priced at a 50% + premium and would not currently be a cost-effective addition to our portfolio. -The Brighter Planet team

New Year, New Offset Policy

2009-01-07T00:00:00+00:00

As we kick off 2009, we’d like to introduce you to our new carbon offset policy. As with most new models, you’ll find that little has changed from our current PANTS policy. But the start of a new year, our second since launching, seemed a good time to pause, reflect, and distill our experience into an update of what constitutes a quality carbon offset.

The result of that process is RATE:

Real

Real offsets are permanent emissions reductions that are properly quantified, audited, and retired. Brighter Planet offsets cannot be invalidated by future events, are tracked and accounted for, and are not double-sold or double-counted.

Additional

A project that is additional would not have been built were it not for the prospect of receiving proceeds from the sale of offsets. Brighter Planet will not invest in projects that would have occurred anyway, as they produce no extra reduction in emissions and therefore do not produce bona fide carbon offsets.

Transparent

Complete transparency throughout the offset lifecycle is essential, given the inherent intangibility of carbon offsets and the absence of regulation in the voluntary market. Brighter Planet’s process includes a public comment period for projects under consideration, disclosure of our Project Selection Committee’s decisions, posting of project documents online, and an annual audit of sales and retirements.

Environmental and Social Value Added

Projects with environmental and social value added fight climate change while also helping solve other pressing challenges facing our communities and ecosystems. Brighter Planet invests in community-based climate solutions that also address issues like public health, biodiversity, poverty, and water quality.

RATE is what our Project Selection Committee will use to evaluate new offset projects being considered for inclusion in our portfolio. We like it, but we also want to know what you think. Please let us know by commenting below.

To see PANTS and RATE side by side, along with an explanation of our changes, click here.

Thanks!

–The Brighter Planet Team

Bank of Americaâs environmental commitments

2008-12-08T00:00:00+00:00

We’re glad to see that Bank of America, our partner for the Brighter Planet Visa, has taken some significant steps to become even more environmentally responsible.

They’ve recently announced that they will:

1) phase out loans to companies that do mountaintop removal for coal production. (BoA Coal Policy)

2) give $1 million to the Harvard Center for the Environment for a study on capturing the greenhouse gas emissions from burning coal.

3) continue to adopt the Carbon Principles. These are guidelines about the risks of investing in greenhouse gas emitting- public utility projects like coal plants.

In the bigger picture, Bank of America has made a broad environmental commitment of $20 billion over the next ten-years. The money will be used to advance sustainability across the board– in its operations, through its lending and investing, and in new products and services.

There’s room for eco-improvement in nearly every organization, but these are important steps for BoA and we at Brighter Planet applaud their efforts.

Carbon Offsets for Agents of Change

2008-12-01T00:00:00+00:00

Today is an important day as almost 11,000 participants gather in Poznań, Poland to talk about climate change. The UN Climate Change Conference will go on through December 12th. These high-level talks are part of the ongoing negotiations to further enhance Kyoto Protocol agreements and to develop a post-Kyoto climate regime. The hope is that this conference will bring the participating nations one step closer to a formal agreement in December 2009.

SustainUS, the US Youth Network for Sustainable Development, sent over a delegation of US-based student leaders who will be involved in the sustainable development policymaking process in Poland. Brighter Planet is honored to have donated 69,138 lbs. of carbon offsets to balance out the Agents of Change delegates’ travel emissions to and from the conference.

This is an exciting opportunity for these youth to see climate policymaking in action. Offsetting the carbon emissions from their travel helps them to lead by example as they develop climate-responsible policy recommendations. We’re looking forward to hearing how things go in Poland!

Drumroll please: the Climate Matters winners

2008-10-21T00:00:00+00:00

Over the last three months, we’ve had the pleasure of running the Climate Matters video contest alongside our partners at 1Sky. Today, we’d like to announce our winners.

Drum roll please…

1^st Place: Climate Matters, by Steven Dempsey 2^nd Place: Ask the Children, by Barbara Lucas 3^rd Place: Green To Blue, by Elizabeth Klein 3^rd Place: This Lawn is Your Lawn, by Roger Doiron

Winning Movies from the Climate Matters Video Contest from Brighter Planet on Vimeo.

You can see them now on our channel.

These four videos, chosen by our distinguished panel of judges, represent the best of over 100 submissions from all around the country. What we at Brighter Planet found striking about the process has been the diversity of content and perspective. It has been made evermore apparent to us that to frame climate change as a youth issue, an energy issue, an environmental issue, etc. is fundamentally flawed. These videos creatively define climate change as an overarching issue. Some paint a daunting and often terrifying picture, while others seek to provide hope and inspiration. What they make clear is that the challenge of tackling climate change is also an opportunity. They urge our next president to act forcefully for the betterment of not only our planet, but its people.

So, thank you to all those who participated; thank you for your energy, emotion, for lending your voices, and faces to this issue. You help to humanize this global challenge, making it more accessible and approachable. Now the fun part; please help get the word out about these amazing videos. Check out our winners and other finalist and embed those you like on your blog, facebook or myspace page, and if you’re really feeling active, send it along to your congressional representative.

Climate Matters: Inspire Our Next President!

2008-07-31T00:00:00+00:00

Well folks, we’ve been waiting for this day for some time now… We’d like to announce the launch of our video contest - Climate Matters: Inspire Our Next President. We’ve partnered with 1Sky, a climate change organization based in Washington DC, and Vimeo, a premier video-sharing website, to make sure our leaders know why climate change must be addressed by our next president. That’s why we’re calling on Americans (that’s you!) to create a 30 or 60 second video to deliver a clear, creative and compelling message to our leaders to take bold action on climate change.

Now, our message to you… What are you waiting for? Grab yourself a camera, it doesn’t have to be fancy, and ask yourself what message you want to deliver to our leaders right now. Serious or funny, amateur or professional, we’re opening the political space for you to share that message. Upload your video on Vimeo’s Climate Matters website, and be sure to self-promote. The top ten videos will be chosen based on average views per day, so you can help your video get to the top! Winning videos will be broadcast to a central audience of over 50 million people nationwide and will be shown to our leaders in Washington.

Check out the contest’s introductory video, you might see some familiar faces!

Climate Matters from Brighter Planet on Vimeo.

Prizes

The top video submission will be awarded with $3000 on a preloaded Brighter Planet Visa Gift Card; 2nd Place, $1000 on a preloaded Brighter Planet Visa Gift Card; and 3rd Place, $500 on a preloaded Brighter Planet Visa Gift Card.

Viewers can also enter a raffle to win a brand new Canon VIXIA HV30 HDV camcorder - next year you’ll have no excuse not to submit a film!

Judges

We’ve got a stellar panel of judges that come from all sides of the political spectrum:

• Gillian Caldwell, Campaign Director and Film Producer, 1Sky • Leila Conners, President and Co-Founder of Tree Media, Producer/Director 11th Hour • Nadia Conners, Creative Director and Co-Founder of Tree Media, Producer/Director 11th Hour • Maggie Gyllenhaal, Actress, Rachel Dawes in Batman the Dark Knight • Anya Kamenetz, author Generation Debt and Staff Writer Fast Company • Rory Kennedy, Director and Producer, Moxie Firecracker Films • David Jenkins, Government Affairs Director Republicans for Environmental Protection • Tia Lessin, Director and Producer, Fahrenheit 9/11, Bowling for Columbine • Patti Prairie, President and CEO, Brighter Planet • Bill Stetson, film producer and environmental consultant

Be sure to know the rules (the terms and conditions are on the contest website)

And don’t doubt yourself for one second, because one video can change the world!

-The Brighter Planet team

350 and still runningâ¦

2008-06-17T00:00:00+00:00

Well, we did it! After just three and a half weeks, we got over 350 bloggers to participate in the 350 Challenge. We’re so impressed by the way the badge spread from blog to blog, from California to Canada to Turkey … now thousands of readers from all over the world are united through this campaign!

I’d like to share for a minute what 122,500 pounds offset means to us, and our vision of building renewable energy in communities across the United States. While a number can sometimes just seem like a number, 122,500 pounds becomes very real when we help families and communities to build renewable energy - to help sustain their livelihood so that they may do their part to stop the country’s addiction to coal and oil.

To understand the real impact of 122,500 pounds offset, we’ve done some math for everyone. 122,500 pounds offset is like turning off all the power in DC for five minutes, it’s also like making your house off the grid for more than five years!

Due to the success of this campaign, and our commitment to helping spread the word about 350.org we’re going to keep the 350 Challenge going for the time being for any new people that want to post our badge. And we’ll still be donating 350 pounds in their name to our renewable energy projects.

Many, many thanks to everyone who participated!

–Emily

Bring on the 350 Challenge!

2008-05-20T00:00:00+00:00

We’re really excited to announce the official launch of the 350 Challenge, done in association with our friends at 350.org. The idea is simple: for every blog that posts the 350 Challenge badge, we’ll offset 350 pounds of carbon in their honor. Yep, that’s it!

Our goal is to reach 350 bloggers, which will offset 122,500 pounds of carbon. That’s like turning off the power in Washington, DC for five minutes!

Just click on the badge to get your own. And if you’ve already done it? Thank you.

Back from Birkie

2008-02-26T00:00:00+00:00

We’ve just returned from the 2008 American Birkebeiner—and what a great event it was. Over 7,000 racers descended on the tiny Wisconsin towns of Cable and Hayward, to compete in the 50km Birkie.

Last year, the event was cut short due to lack of snow. No problems this year, however, with a two-foot base and fast, cold snow over the whole course. The winning time, posted by Ivan Babikov of Canada, was 2 hours and seven minutes… that’s 24 km/hr over rolling hills and flat fields!

Kate Whitcomb, a Brighter Planet ambassador, battled a head cold to finish fifth in the women’s Birkie. Through our event offsetting program and direct offset sales, over 48 tons of carbon dioxide were offset— supporting farmer-owned distributed wind projects in Minnesota and South Dakota.

A small recycling program was started, diverting countless bags of cardboard from the landfill. These represent Brighter Planet’s first steps in our Keep Winter White campaign. We hope to return next year, to make the event even greener.

www.flickr.com

Thanks to Ned Zuelsdorff, Executive Director of the American Birkebeiner and his entire team for pulling together such a fantastic event.

Short TV piece on Brighter Planet from NECN

2007-12-12T00:00:00+00:00