The Problem

Skype connectivity sometimes drops calls. It is also challenging to schedule with multiple people. We already use Google Apps so it made sense since it would integrate with our other systems so easily.

The Fix

We having using Google Hangouts and have been very pleased with the results so far.

The setup is more involved than using Skype so I am going to detail the steps involved.

3 Things have to be done in order to use a Hangout.

1. You first must be a member of Google+. If you are doing this for your @pivotallabs.com Google identity make sure you are signing up with your corporate email address and not your personal Google account. Join at plus.google.com.

2. Enable the Google Video Chat plugin or download from here.

3. Start a Hangout

   • Go to plus.google.com/hangouts and click the Start a Hangout button on the top right side of your screen.
   • Click the Hangouts icon underneath an interesting post on your Home page to start a hangout about the post.
   • Click the Hangouts icon on the left side of the page and click Start a hangout under the ‘HANGOUT INVITE’ section.
   • You can also start a hangout and send and receive hangout invites from other Google properties including:
     Google Chat properties (ie. Gmail, Google+, iGoogle, orkut) Learn more.
   • Google Calendar Learn more.

Neat things you can do with a Hangout

Schedule a recurring meeting with the same Hangout address

This is very handy for a meeting which happens repeatedly so that you always have the same URL to join, like a standup meeting. This was first found by Joe Moore from Pivotal on this blog entry by David Cummings

The steps are as follows:

• Create a new event on Google+ Events.
• Give the event a date far into the future, like the year 2020
• Go to Event options -> Advanced and click on Google+ Hangout
• Save the event
• Share the link to the Google+ Hangout on your repeating Google Calendar event

Get a better quality output if you are doing a live music Hangout using Studio Mode.

Create a Hangout very quickly by using the chat window when signed into your Google email and clicking on the Hangout icon or create an event on your Google calendar and add a Hangout to the event.

Improved Camera

We also found that upgrading the webcam you are using can help to improve your experience. We have upgraded to the Logitech HD Pro Webcam C910. This version is Mac compatible, the newer model which is the C920 is not. The 910 provides improved optics with a better lens and an improved depth of field. This version is also easily portable if you have a laptop.

Summary

We only expect the Google Hangout to get better as Google keeps working to improve it. So far it has been a big improvement over Skype.

This week I worked on a new web interface for our open source project License Finder.

The license_finder gem persists dependency information out to a YAML file; however, we wanted to persist these same
dependency objects to a SQL database for the website.

Step 1: Persistence base class

In order to accomplish this, I had to perform a series of refactorings that would make it possible to swap out YAML persistence
with an ActiveRecord persistence layer. The LicenseFinder::Dependency class had never been setup make persistence injectable,
so the first step was moving all persistence-related functionality out into a seperate base class, and giving it an ActiveRecord-style API:

module LicenseFinder
  module Persistence
    class Dependency
      class Database
        #... YAML 'database' implementation details
      end

      attr_accessor *LicenseFinder::DEPENDENCY_ATTRIBUTES

      class << self
        def find_by_name(name)
          attributes = database.find { |a| a['name'] == name }
          new(attributes) if attributes
        end

        def delete_all
          database.delete_all
        end

        def all
          database.all.map { |attributes| new(attributes) }
        end

        def unapproved
          all.select {|d| d.approved == false }
        end

        def update(attributes)
          database.update attributes
        end

        def destroy_by_name(name)
          database.destroy_by_name name
        end

        private
        def database
          @database ||= Database.new
        end
      end

      def initialize(attributes = {})
        update_attributes_without_saving attributes
      end

      def config
        LicenseFinder.config
      end

      def update_attributes new_values
        update_attributes_without_saving(new_values)
        save
      end

      def approved?
        !!approved
      end

      def save
        self.class.update(attributes)
      end

      def destroy
        self.class.destroy_by_name(name)
      end

      def attributes
        attributes = {}

        LicenseFinder::DEPENDENCY_ATTRIBUTES.each do |attrib|
          attributes[attrib] = send attrib
        end

        attributes
      end

      private
      def update_attributes_without_saving(new_values)
        new_values.each do |key, value|
          send("#{key}=", value)
        end
      end
    end
  end
end

With all of the persistence-related functionality in this base class, I could now update the LicenseFinder::Dependency class to inherit from this:

module LicenseFinder
  class Dependency < LicenseFinder::Persistence::Dependency
    #...
  end
end

I also created a shared example for describing how persistence should work (regardless of the underlying persistence implementation):

shared_examples_for "a persistable dependency" do
  let(:klass) { described_class }

  let(:attributes) do
    {
      'name' => "spec_name",
      'version' => "2.1.3",
      'license' => "GPLv2",
      'approved' => false,
      'notes' => 'some notes',
      'homepage' => 'homepage',
      'license_files' => ['/Users/pivotal/foo/lic1', '/Users/pivotal/bar/lic2'],
      'readme_files' => ['/Users/pivotal/foo/Readme1', '/Users/pivotal/bar/Readme2'],
      'source' => "bundle",
      'bundler_groups' => ["test"]
    }
  end

  before do
    klass.delete_all
  end

  describe '.new' do
    subject { klass.new(attributes) }

    context "with known attributes" do
      it "should set the all of the attributes on the instance" do
        attributes.each do |key, value|
          if key != "approved"
            subject.send("#{key}").should equal(value), "expected #{value.inspect} for #{key}, got #{subject.send("#{key}").inspect}"
          else
            subject.approved?.should == value
          end
        end
      end
    end

    context "with unknown attributes" do
      before do
        attributes['foo'] = 'bar'
      end

      it "should raise an exception" do
        expect { subject }.to raise_exception(NoMethodError)
      end
    end
  end

  describe '.unapproved' do
    it "should return all unapproved dependencies" do
      klass.new(name: "unapproved dependency", approved: false).save
      klass.new(name: "approved dependency", approved: true).save

      unapproved = klass.unapproved
      unapproved.count.should == 1
      unapproved.collect(&:approved?).any?.should be_false
    end
  end

  describe '.find_by_name' do
    subject { klass.find_by_name gem_name }
    let(:gem_name) { "foo" }

    context "when a gem with the provided name exists" do
      before do
        klass.new(
          'name' => gem_name,
          'version' => '0.0.1'
        ).save
      end

      its(:name) { should == gem_name }
      its(:version) { should == '0.0.1' }
    end

    context "when no gem with the provided name exists" do
      it { should == nil }
    end
  end

  describe "#config" do
    it 'should respond to it' do
      klass.new.should respond_to(:config)
    end
  end

  describe '#attributes' do
    it "should return a hash containing the values of all the accessible properties" do
      dep = klass.new(attributes)
      attributes = dep.attributes
      LicenseFinder::DEPENDENCY_ATTRIBUTES.each do |name|
        attributes[name].should == dep.send(name)
      end
    end
  end

  describe '#save' do
    it "should persist all of the dependency's attributes" do
      dep = klass.new(attributes)
      dep.save

      saved_dep = klass.find_by_name(dep.name)

      attributes.each do |key, value|
        if key != "approved"
          saved_dep.send("#{key}").should eql(value), "expected #{value.inspect} for #{key}, got #{saved_dep.send("#{key}").inspect}"
        else
          saved_dep.approved?.should == value
        end
      end
    end
  end

  describe "#update_attributes" do
    it "should update the provided attributes with the provided values" do
      gem = klass.new(attributes)
      updated_attributes = {"version" => "new_version", "license" => "updated_license"}
      gem.update_attributes(updated_attributes)

      saved_gem = klass.find_by_name(gem.name)
      saved_gem.version.should == "new_version"
      saved_gem.license.should == "updated_license"
    end
  end

  describe "#destroy" do
    it "should remove itself from the database" do
      foo_dep = klass.new(name: "foo")
      bar_dep = klass.new(name: "bar")
      foo_dep.save
      bar_dep.save

      expect { foo_dep.destroy }.to change { klass.all.count }.by -1

      klass.all.count.should == 1
      klass.all.first.name.should == "bar"
    end
  end
end

Step 2 – Make persistence autoloadable

Next, I wanted to make persistence autoloadable in the gem (so that other persistence solutions could simply create their own
LicenseFinder::Persistence::Dependency implementation before doing a require "license_finder":

module LicenseFinder
  module Persistence
    autoload :Dependency, 'license_finder/persistence/yaml/dependency'
    autoload :Configuration, 'license_finder/persistence/yaml/configuration'
  end
end

Step 3 – Create new persistence implementation

Now, creating an ActiveRecord persistence implementation was as simple as:

module LicenseFinder
  module Persistence
    class Dependency < ActiveRecord::Base
      serialize :license_files
      serialize :readme_files
      serialize :bundler_groups
      serialize :children
      serialize :parents

      belongs_to :config

      scope :unapproved, where(approved: false)
    end
  end
end

require "license_finder"

And the test for this persistence implementation:

require "spec_helper"
require_relative "path/to/LicenseFinder/spec/support/shared_examples/persistence/dependency.rb"

describe LicenseFinder::Persistence::Dependency do
  it_behaves_like "a persistable dependency"
end

Earlier in the year I said that joining EMC would turbocharge Pivotal Labs’ business, and that is certainly proving to be the case. Today I am very pleased to announce the launch of Pivotal’s new product management practice, expanded design services, and the opening soon of two regional offices in Boston and Los Angeles, as well as our first office in Europe, to be based in London. To help guide the company during this growth stage we have appointed several executives to lead key business functions.

Our product management and design services can now help clients plan, define, prioritize, and design their entire product and strategic roadmap to promote greater efficiency throughout the entire development process. We can take great satisfaction in knowing we are helping our clients build quality products and deliver them to market faster through our focus on a creative culture and uniquely disciplined processes.

No doubt those of you who spend any appreciable time at Pivotal will have noticed a few new faces in the hallways. I am delighted to formally announce several executive appointments:

• Edward Hieatt, who has served as our Vice President of Engineering, has been promoted to Chief Operating Officer;
• Matt Eng has been appointed Chief Financial Officer;
• Drew McManus will lead the new design and product management practice as Vice President of Product;
• Melissa Dyrdahl has joined as Vice President of Marketing.

At the end of the day it’s all about delivering results faster while continuing to focus on improving the customer experience. Our clients have asked Pivotal for these new services, and we are proud to be able to deliver them.