Kellogg Associates

Above the Bay Area

gregg@kellogg-assoc.com (Gregg Kellogg) — Thu, 15 May 2008 09:48:00 -0500

Recently, my good friend and local traffic reporting luminary, Stan Burford, got me up in the KGO Radio Traffic helicopter on a beautiful day where I could put my Nikon D200 through it’s paces. I think you’ll enjoy the results. We’re blessed here in the Bay Area with some of the most beautiful scenery in the country.

Picture can be found through the photography page on my site, or directly here

The ships you see are known as the Mothball Fleet. They include the Glomar Explorer, famous for attempting the recovery of a Soviet Submarine during the Cold War, and the USS Iowa battleship.

Other notable highlights were

an orbit around my house in San Rafael,
two passes by the Golden Gate Bridge,
the Palace of Fine Arts,
Fisherman’s Wharf,
Coit Tower,
San Francisco Skyline,
AT&T Park,
the Bay Bridge,
a shot of the KGO TV helicopter, and
McAfee park, home of the Oakland A’s, who you can see warming up on the field.

Thanks to Gary and Terry (reporter and pilot) for making this a most memorable experience!

Gregg

Italy & France 2007

gregg@kellogg-assoc.com (Gregg Kellogg) — Sat, 13 Oct 2007 11:36:00 -0500

Here are some pictures from our trip to Lake Como and Provence.

Enjoy,

Gregg & Rebecca

Channel Islands July 2007

gregg@kellogg-assoc.com (Gregg Kellogg) — Wed, 18 Jul 2007 16:59:00 -0500

Here are some pictures from my recent trip to the Channel Islands including San Clemente, Catalina and Santa Cruz Islands.

Enjoy,

Gregg

Channel Islands May 2007

gregg@kellogg-assoc.com (Gregg Kellogg) — Sat, 02 Jun 2007 17:44:00 -0500

Here are some pictures from my recent trip to the Channel Islands, including two days at San Miguel Island.

Enjoy,

Gregg

ActiveWarehouse

gregg@kellogg-assoc.com (Gregg Kellogg) — Sat, 19 May 2007 18:10:00 -0500

Related to the interesting talk at a recent NBRug meeting on Ruport, I’ve been looking at doing data warehousing in Ruby. Fortunately, Anthony Eden has beaten me to the punch with ActiveWarehouse.

For those unfamiliar with Data Warehousing, the concepts are basically to create a series of facts that are indexed buy multiple dimensions. A fact is typically an integer (eg, sales amount) with data relating to the fact expressed in dimensions. (Note that in some cases, you can have a Factless Fact table where the information is entirely in the dimensions). Dimensions provide different types of data relating to the fact (e.g., date & time of entry, user, product, location, etc.), so a fact table has a column for each ’’dimension’’ with a column for the fact scalar value itself.

The ’’dimension’’ tables contain an id index column, a column for the fact value (e.g., timestamp for date & time) and columns for each ’’summary’’ to be associated with the dimension (e.g., day of week, day of month, month, year, hour minute, ...).

At this point, queries can be performed by joining the dimension and fact tables and summarizing (or counting) the scalar fact value against conditions against the dimension tables (e.g., sales per year by person and region).

Typically, this data is pre-summarized in ’’cubes’’ with summary tables that contain the results of these summary queries.

The ActiveWarehouse plugin contains everything necessary to define, populate and report on this data.

I expect to be using this to hold information on user listening habits for MP3 files.

Gregg Kellogg

Bonaire May 2007

gregg@kellogg-assoc.com (Gregg Kellogg) — Thu, 10 May 2007 09:12:00 -0500

Pictures from dive trip to Bonaire in May 2007.

RailsConf Sessions

gregg@kellogg-assoc.com (Gregg Kellogg) — Thu, 26 Apr 2007 15:05:00 -0500

Here are the sessions Ill be attending at RailsConf. Hope to see you there.

Gregg

Observers in Rails 1.2

gregg@kellogg-assoc.com (Gregg Kellogg) — Fri, 26 Jan 2007 21:13:00 -0600

Thanks to Rick Olson for providing assistance with the proper syntax for instantiating observers in Rails 1.2. The old way was to add an observer statement to the appropriate controler, such as:

observer :user_observer

Hidden in the ignored parts of conf/environment.rb was the proper notation:

# Activate observers that should always be running
# config.active_record.observers = :cacher, :garbage_collector

This makes the last of my deprecation messages go away!

Gregg

Eager Finder SQL

gregg@kellogg-assoc.com (Gregg Kellogg) — Sun, 05 Nov 2006 19:31:00 -0600

EagerFinderSql allows custom SQL to be specified when doing eager loading of associations through the :include option to find. This allows for purpose-constructed queries to be used and still result in a fully linked object model.

Background

ActiveRecord constructs SQL to satisfy the requirements of a find request. Associations allow for customized SQL to be specified, using the :finder_sql option, but this has not been available when performing eager loading using the :include option. The result is that a standardized query is constructed to bring in the associated tables using LEFT OUTER JOIN. For some queries, this can be result in expensive queries and potentially very large result sets.

Custom SQL

EagerFinderSql addresses this problem by allowing :finder_sql to be added to find options when the :include option is also specified.

Columns in the result set are mapped to attributes in the resuting object model through the :column_mapping option.

The :column_mapping option specifies a hash containing the following entries:

primary_key – indicates the column alias associated with the classes id attribute.
columns – is a hash of attribute to column alias associations.
associatios – is a hash of association mappings for each directly included model. The key for each entry is the name of the association, while the value is a hash similar to the hash for the parent class.

Example

Consider the following query relating authors with many books:


Author.find(:all, :include => :books)

This would likely produce the following SQL:


SELECT
    authors.id AS t0_c0, authors.name AS t0_c1,
    books.id AS t1_c0, books.author_id AS t1_c1, books.title AS t1_c2
  FROM authors
  LEFT OUTER JOIN books ON books.author_id = authors.id

The query might be written with books as the driver, rather than authors as follows:


 SELECT
    authors.id, authors.name,
    books.id AS book_id, books.name AS book_name
  FROM books
  JOIN authors ON authors.id = books.author_id

The Rails query would then be written as follows:


Author.find(:all, :include => books,
           :finder_sql => " 
                SELECT
                    authors.id, authors.name,
                    books.id AS book_id, books.name AS book_name
                  FROM books
                  JOIN authors ON authors.id = books.author_id".
           :column_mapping => {
             :primary_key => 'id',
             :columns => {
                  'id'  => 'id',
                  'name => 'name'
              },
              :associations => {
                :books => {
                  :primary_key => book_id,
                  :columns => {
                      'id'        => 'book_id',
                      'author_id' => 'id',
                      'name'      => 'book_name
                  }
                }
              }
            })

This is more verbose, but allows for absolute control of the SQL used to return results across multiple model associations.

A more complicated example would be the following:


QUERY = " 
SELECT
    a.id AS author_id,
    a.name AS author_name,
    p.id AS post_id,
    p.title AS post_title,
    p.body AS post_body,
    p.type AS post_type,
    c.id AS comment_id,
    c.body AS comment_body,
    c.type AS comment_type
  FROM authors a
  LEFT JOIN posts p ON p.author_id = a.id
  LEFT JOIN comments c ON c.post_id = p.id" 

MAPPING = {
  :primary_key => 'author_id',
  :columns => {
    'id' => 'author_id',
    'name' => 'author_name'
  },                         
  :associations=> {
    :posts => {
      :primary_key  => 'post_id',
      :columns => {
        'id' => 'post_id',
        'title' => 'post_title',
        'author_id' => 'author_id',
        'body' => 'post_pody',
        'type' => 'post_type'
      },
      :associations => {
        :comments => {
          :primary_key  => 'comment_id',
          :columns => {
            'id' => 'comment_id',
            'post_id' => 'post_id',
            'author_id' => 'author_id',
            'body' => 'comment_body',
            'type' => 'comment_type'
          }
        }
      }
    }
  }
}
Author.find(:all,
            :include=>{:posts=>:comments},
            :order=>"authors.id",
            :finder_sql => QUERY,
            :column_mapping => MAPPING)

This example shows the recursive nature of associations. It can also be used to render deeper structures that may reference the same model multiple times, such as the following:


Firm.find(:all,
          :include=>{:account=>{:firm=>:account}},
          :order=>"companies.id")

(Here, the query and mapping is left to the reader; or, you can look at the unit test which documents many more possibilities).

Install using


script/plugin install svn://rubyforge.org/var/svn/eagerfindersql

The plugin is managed on RubyForge. Rdoc is available.

Project Communication

gregg@kellogg-assoc.com (Gregg Kellogg) — Thu, 02 Nov 2006 12:00:00 -0600

Many software projects fail to deliver on-time and on-budget and a factor in that is normally inefficient project communication. Studies have shown that software teams that consistently deliver on-time and on-budget communicate in an effective manner. These teams stay in contact constantly, but wisely use each other’s time during the communication process and are careful not to waste other people’s time.

Below are some tips for enhancing project communication when working in software development projects:

Set up an online repository for documentation – For effective communication, all your project documents should be online, up-to-date, and available at everyone’s finger tips. This includes requirement documents, detailed designs, test plans, project plans, status reports, user acceptance plans, post mortem documents, etc. Having all of these documents at everyone’s disposal ensures that everyone is working on the same set of deliverables. Many groups usefully solve this problem by setting up a department Wiki that acts as a convenient location for storing and updating important project information such as documentation.
Specify Clear Roles and Responsibilities – For effective communication, everyone on the team should know what their role is and what they are accountable for. Each role should be documented during the initial phases of the project and every team member should sign off on their responsibilities. Post these in your online documentation repository.
Monitor Employee Performance – Each employee should have defined goals and should be measured against their goals monthly or quarterly (depending on project duration). Goals should be specific, measurable and achievable. Progress to goals should be based on objective measurement.
Progress Reports – Progress reports should be created weekly. This can be as informal as creating a weekly status report for management review or as formal as creating reports using a project planning tool. Consider using a tool for this, some good ones are Software Planner and Microsoft Project.
Make Decisions based on Facts – All decisions should be objective and should not be self-serving. Decisions should be based on facts, performance and in the spirit of improving overall team performance.
Project Tracking should be done Online – All phases of the Software Lifecycle should be managed online, preferably via the web. This includes managing of requirements, tasks, issues, defects, test cases. sharing knowledge with discussion forums and your document repository.
Be Careful of People’s Time – It is good to have periodic meetings, but the presence of solid project tracking tools eliminates many of the long-winded meetings that teams have. Team members are most productive when they know their roles, responsibilities and have a way of showing progress online. This can greatly reduce the number of face-to-face meetings that are needed.

(Thanks to Steve Miller of Pragmatic Software for insights into these issues.)

Gregg Kellogg