BrewSession Blog

Australian Ale Style Descriptions

gregr — Thu, 03 Jul 2008 01:19:11 +0000

Just a quick plug to check out The Missing BJCP Styles, part 2: Going Down Under with Australian Ales over on my personal blog. In this post, I cover Australian Pale/Sparkling Ale, Australian Dark Ale, and Australian Wheat Beer. I’ll be following that up shortly with a post on Australian Lagers. As with all the styles in the “Missing Styles” series, BrewSession will include these Australian styles in its style list.

Problematic Decimal Arithmetic in Javascript

Dean — Sun, 29 Jun 2008 06:09:10 +0000

It is a pretty well known fact that using javascript to add decimals 0.1 with 0.2 does not result in 0.3. ^[1] Try it yourself with the FireBug console. For the uninitiated, the problem stems from javascript’s internal representation of numbers. They are actually binary numbers that are usually exact, but sometimes for example, are 0.00000000000000004 off. This is particularly aggravating when writing calculators that rely on js to give accurate results.

In my text inputs I was using toFixed() and some magic HTML attributes to keep decimals nice and clean. However, this method breaks down when a user enters a number with more significant figures than initially set up or you try to operate on two numbers with different sig figs. It was probably inevitable that I use a little arithmetic library extending Number to make decimals play nice.

Since javascript is 13 years old I thought it would be a simple thing to find such a library. I was wrong. After four days learning, looking and lamenting I had no library. After putting this one together in about a day and a half I am not surprised that nobody published theirs. Most of the eleven functions are one-liners, yet it bothers me that there are probably thirty-odd implementations of the this out there and not one found through Google.

// decimal_arithmetic.js
String.prototype.digitsAfterDecimal = function()
{ var parts = this.split(".", 2); // FIXME: Not international!
if( ! parts[1] )
{ parts[1] = ""; }
return parts[1].length;
};
Number.prototype.biggerScalar = function(n)
{ return n.scale() > this.scale() ? n.scale() : this.scale(); };
Number.prototype.digitsAfterDecimal = function()
{ return this.toString().digitsAfterDecimal(); };
Number.prototype.divided = function(n)
{ return this.dividedBy(n); };
Number.prototype.dividedBy = function(n)
{ return this.multiply( n.reciprocal() ); };
Number.prototype.minus = function(n)
{ return this.plus( n.negative() ); };
Number.prototype.multiply = function(n)
{ var s = this.biggerScalar(n);
return (Math.round(s*this,0) * Math.round(s*n,0)) / (s*s);
};
Number.prototype.negative = function()
{ return -1 * this; };
Number.prototype.plus = function(n)
{ var s = this.biggerScalar(n);
return (Math.round(s*this,0) + Math.round(s*n,0)) / s;
};
Number.prototype.reciprocal = function()
{ return 1 / this; };
Number.prototype.scale = function()
{ return Math.pow(10, this.digitsAfterDecimal() ); };

Now you can do magical things like:

0.1.plus(0.2)
// 0.3

yielding the correct results.

I am looking forward to javascript 2.0 when I can override the + operator. Maybe I won’t go that far since binary arithmetic is still faster.

[1] http://groups.google.com/group/comp.lang.javascript/…

The Missing Beer Styles, Making it into BrewSession

gregr — Thu, 24 Apr 2008 05:28:18 +0000

Sticke Alt, Australian Sparkling Ale, Leipziger Gose, Classic American Cream Ale, Imperial Lager. What do all these beer styles have in common? Done guessing? Hint: They’re not in the Beer Judges Certification Program Style Guidelines. Nor are a lot of other lesser-known beer styles. The BJCP Style Guide is the main source of style guidelines used by home and microbrewers in the US, and beyond. But it has its purpose, educating beer judges. For a brewer, it’s just not quite complete.

As noted previously, we’ll be including the FULL BJCP Beer Style Guidelines in BrewSession. However, lately, as I’ve brewed my last few batches of beer that didn’t fall into a BJCP specified style, I started thinking about those “missing styles”.

Certainly there are many, many modern and ancient styles that aren’t in the BJCP style guidelines. Some are just too obscure, some are even commercially extinct. But there are some styles that, still, deserve to be recognized … somehow.

Some of these obscure styles even get brief mentions in the BJCP Style Guide as part of another similar or contrasting style. Others are mentioned in BJCP Style Category 23A which is purposely labeled a “catch-all” category of beers that don’t have their own category. Wouldn’t it be nice to have some guidelines to help you brew all those styles that haven’t made it into the official BJCP Style Guide?

There are well over 20 styles that are of major interest to the home and micro-brewer that I think need to be honored with a style guideline. So, recently I started researching and posting about several of these “missing” styles on my own blog, “Food, Beer & Buffoonery” . I started with two varieties of German Altbier that are different enough from the standard Alt to deserve mention: Sticke Ale and Münster Alt.

I’ll be periodically adding more posts about other non-BJCP beer styles that are of interest to us brewers. I’ll also be continually updating previous style posts as new information comes in. With all of these, I’ll be “attempting” (with big help from many of you) to create a BJCP-like style description for each of these, so that we can eventually include these “missing styles” into BrewSession. Then, when you have the guidelines at your fingertips, you’ll be able to accurately brew that Sticke Alt, that Australian Sparkling Ale, that Leipziger Gose, that Classic American Cream Ale …

Upcoming styles in the series will include, but are not limited to: Kellerbier, Gose, Wiess, Honey Beers, Classic American Cream Ale, Czech Dark Lager, English Pale Mild, Scottish 90/-, American Stock Ale, English Strong Ale, Non-alcoholic “Beer”, Malt Liquor, Australian Sparkling Ale, Imperial/Double Red Ale, Imperial/Double Brown Ale, Imperial Lager, Imperial Pilsner, Imperial Porter, Rye IPA, Dark American Wheat/Rye.

Extending acts_as_commentable

Dean — Sun, 13 Apr 2008 04:48:59 +0000

acts_as_commentable is a nice little ruby on rails plugin. It extends your ActiveRecord classes giving them comments. We are going to use comments on all kinds of things, starting with recipes, of course. However, AAC lacks a critical feature: the ability for users to approve comments before they are displayed. In this post I am going to run through extending AAC using acts_as_state_machine.

The first thing I did (and do to all the plugins we use) was pistonize the plugin so I could hack on it without fear of getting my changes destroyed.

I start off simply here by adding two states to the Comment model: :pending and :approved.

class Comment < ActiveRecord::Base
# The first element of this array is the initial state
VALID_STATES = [ :pending, :approved ]
acts_as_state_machine :initial => VALID_STATES[0]
event :approve do
transitions :from => :pending, :to => :approved
end
VALID_STATES.each do |_state|
# Define _state as a state
state _state
end
# More code snipped
end

Now we are going to write some real code, so here comes a little RSpec. aac provides three class methods:

class Comment < ActiveRecord::Base
class << self
# Helper class method to lookup all comments assigned
# to all commentable types for a given user.
def find_comments_by_user(user)
# Helper class method to look up all comments for
# commentable class name and commentable id.
def find_comments_for_commentable(commentable_str, commentable_id)
# Helper class method to look up a commentable object
# given the commentable class name and id
def find_commentable(commentable_str, commentable_id)
end

Since it didn’t come with Test::Unit or RSpec tests I wrote up some test for these methods.

describe Comment, "class methods" do
fixtures :comments, :recipes, :users
it "should find comments by user" do
Comment.find_comments_by_user( comments(:comment_one).user ).should all_belong_to( comments(:comment_one).user )
end
# This could be more specific
it "should find comments for a particular class" do
Comment.find_comments_for_commentable( Comments(:comment_one).commentable_type, comments(:comment_one).commentable_id ).should be_an_instance_of(Array)
end
it "should find all comments for a particular class" do
# I happen to know that comment_one is a recipe comment
Comment.find_commentable( "Recipe", comments(:comment_one).commentable_id ).should be_an_instance_of(Recipe)
end
end

If you are confused by should all_belong_to then you should check out my previous post. With these specs out of the way we can go on to adding more new code.

it "should find approved comments by user" do
Comment.find_approved_comments_by_user( comments(:comment_one).user ).should all_be_in_state("approved")
end
it "should find pending comments by user" do
Comment.find_pending_comments_by_user( comments(:comment_one).user ).should all_be_in_state("pending")
end
end

Now, normally you would write one spec at a time, but I think I would bore my readers, so I combined these two. Also take note that I am using another custom RSpec matcher all_be_in_state(). It looks a lot like all_belong_to(), so I leave its implementation as an exercise to the reader (unless I can get another blog post out of it). To get these tests to pass I add a few lines of code:

VALID_STATES.each do |_state|
# Define _state as a state
state _state
# Add Comment.find__comments methods
( class << self; self; end ).instance_eval do
define_method "find_#{_state}_comments_by_user" do |_user|
find_in_state( :all, _state, :conditions => ["user_id = ?", _user.id], :order => "created_at DESC" )
end
end
end

I am not a method_missing kind of guy, and prefer the dynamic-method metaprogramming style. This lot of code defines class methods at runtime that find Comments in specific states. I am actually using whytheluckystiff’s metaid to hide some of the meta-junk, but I thought I should spell it out here for clarity.

Well, now we have a Comment class with two states and code to limit finds to cmments in a specific state. Right now, that is all I have. Here is the full code for the Comment class and the RSpec. You will see another custom RSpec matcher here, require_a().

class Comment < ActiveRecord::Base
# The first element of this array is the initial state
VALID_STATES = [ :pending, :approved ]
acts_as_state_machine :initial => VALID_STATES[0]
belongs_to :commentable, :polymorphic => true
belongs_to :user
event :approve do
transitions :from => :pending, :to => :approved
end
validates_associated :user
validates_presence_of :comment, :commentable_id, :commentable_type, :state, :user_id
VALID_STATES.each do |_state|
# Define _state as a state
state _state
# Add Comment.find__comments methods
meta_def "find_#{_state}_comments_by_user" do |_user|
find_in_state( :all, _state, :conditions => ["user_id = ?", _user.id],
:order => "created_at DESC" )
end
end
class < < self
# Helper class method to look up a commentable object
# given the commentable class name and id
def find_commentable(commentable_str, commentable_id)
commentable_str.constantize.find(commentable_id)
end
# This could be refactored into find__comments_by_user (somehow)
def find_comments_by_user(_user)
find( :all, :conditions => ["user_id = ?", _user.id],
:order => "created_at DESC" )
end
# Helper class method to look up all comments for
# commentable class name and commentable id.
def find_comments_for_commentable(commentable_str, commentable_id)
find( :all,
:conditions => [ "commentable_type = ? and commentable_id = ?",
commentable_str, commentable_id ],
:order => "created_at DESC" )
end
end
end

require File.dirname(__FILE__) + ‘/../../../../spec/spec_helper’
module CommentSpecHelper
end
describe Comment do
fixtures :comments
include CommentSpecHelper
before(:each) do
@comment = Comment.new
end
it "should start out in pending state" do
@comment.state.should == "pending"
end
it "sould transition to approved" do
@comment = comments(:pending_comment)
@comment.approve!
@comment.state.should == "approved"
end
it "should require a comment" do
@comment.should require_a(:comment)
end
it "should require a commentable_id" do
@comment.should require_a(:commentable_id)
end
it "should require a commentable_type" do
@comment.should require_a(:commentable_type)
end
it "should require a state" do
@comment.should require_a(:state)
end
it "should require a user_id" do
@comment.should require_a(:user_id)
end
end
describe Comment, "class methods" do
fixtures :comments, :recipes, :users
it "should find all comments for a particular class" do
# I happen to know that comment_one is a recipe comment
Comment.find_commentable( "Recipe", comments(:comment_one).commentable_id ).should be_an_instance_of(Recipe)
end
it "should find comments by user" do
Comment.find_comments_by_user( comments(:comment_one).user ).should all_belong_to( comments(:comment_one).user )
end
it "should find approved comments by user" do
Comment.find_approved_comments_by_user( comments(:comment_one).user ).should all_be_in_state("approved")
end
it "should find pending comments by user" do
Comment.find_pending_comments_by_user( comments(:comment_one).user ).should all_be_in_state("pending")
end
# This could be more specific
it "should find comments for a particular class" do
Comment.find_comments_for_commentable( comments(:comment_one).commentable_type, comments(:comment_one).commentable_id ).should be_an_instance_of(Array)
end
end

–Dean

belong_to RSpec matcher

Dean — Thu, 10 Apr 2008 00:59:49 +0000

I was extending acts_as_commentable and needed a good RSpec test to check the returned objects from its finder methods belonged to the correct user. For example, Comment.find_comments_by_user( :some_user ) should all belong_to :some_user. I’ll be darned if that doesn’t look like a RSpec description. Since there is no all_belong_to matcher, I wrote one.

module ActiveRecordValidations
class BelongTo
def initialize(expected)
@expected = expected
end
def matches?(args)
args.all? do |target|
@target = target
@target.send(@expected.class.to_s.downcase) == @expected
end
end
def failure_message
"expected #{@target.inspect} to all belong to #{@expected}"
end
def negative_failure_message
"expected #{@target.inspect} not to all belong to #{@expected}"
end
end
def belong_to(expected)
BelongTo.new( [expected] )
end
def all_belong_to(expected)
BelongTo.new( expected )
end
end

The matches? method takes an array of objects and goes through them with all? checking that they have a belongs_to the expected thing. Using the example above, each comment object returned by Comment.find_comments_by_user would get tested if comment.user== @user.

–Dean

BJCP Beer Style Guidelines Updated for 2008

gregr — Wed, 26 Mar 2008 01:35:28 +0000

Last month the Beer Judges Certification Program (BJCP) released a minor update to their 2004 Style Guidelines. The new “2008 update to the 2004 style guidelines” (as it is officially called) includes some updated style parameters, changes to style descriptions, revised commericial examples for most beer styles and some significant rework to many Belgian ale styles.

In BrewSession we’re using the XML format of the BJCP style guidelines. So as soon as I saw that the 2008 updates had been released, I wanted to make sure we got those into BrewSession as soon as possible. I contacted the BJCP and found that no one was working on updating the BJCP XML. I attempted to contact the original author of the BJCP XML without success (Chris, if you’re out there, give us a hollar, I have some questions). So, I volunteered to update the BJCP XML to the 2008 version.

The BJCP describes it as a minor update, and while there aren’t any new beer styles in the 2008 update, or high level category changes, the number of revisions made to the “fine print” are fairly numerous. While tedious, comparing the 2008 styles with the 2004 XML and making the needed changes is quite interesting, as I’m getting to know the styles like I never did before. In fact, I started going through the styles on my own, buying 2-3 representatives of each style, taking some sips, and reflecting on the style guidelines. My own BJCP course! Dean’s already a certified BJCP judge, but I’m not. However, I think at the end of this I’ll be prepared to take the exam.

In addition to updating the text of the styles, I’m recommending that some elements of the XML be changed, enhanced and updated to make the BJCP Styles XML document more useful to a wider range of people and applications. I’ll be posting my proposals here shortly…

The Kilogram is getting lighter

gregr — Wed, 19 Mar 2008 07:21:17 +0000

So you’re weighing out your ingredients. Perhaps you’re not in the US … or maybe you are in the US and have a degree in science … whichever, you may be weighing out your grains using the metric system. While the root unit of mass is the gram, the metric system of mass is calibrated to a known weight of 1 kilogram. More specifically to the weight of “a cylinder of platinum-iridium kept in a vault near Paris since 1889.”

The problem is, the kilogram is getting lighter… Discover magazine online published a recent article on this that I thought I’d share here. No, it doesn’t mean much for BrewSession. As long as we stick with the conversion of 1kg = 2.204622622 US pounds, I think we’ll be okay. If you read the article, you’ll find that the kg has only lessened in mass by about the weight of a grain of salt since 1889. Interesting nonetheless.

On another note, I’ve got 8 or so calculators ready to go…apart from the toggles having a slight issue that I’m working out. As soon as I’m finished there, we’ll be releasing them to beta testers. (I know, I know…we keep saying that…but honestly, they’re actually working!!!, I just need to get a few minor bugs ironed out before the beta release (we’re not getting paid for this, you know ;-)….and Dean’s been hounding me to get the design of the recipe formulation screen closer to final draft form as he has a generic Ruby on Rails + Ajax version almost ready to be styled up and and used. And I’m holding him back. Hmpf.)

I’ve also been looking into solutions for making BrewSession a desktop application as well as a web application. Most recently I’ve been really getting into Adobe’s AIR technology — going so far as to getting a calculator or two running as desktop apps using AIR technology. It’s really quite nice. The only catch is, you have to have the AIR runtime on your system in order for them to work (similar to having the Java runtime installed to run Java applications). But, AIR is a fairly small, painless download and install. Once you have it, each AIR application installs and runs with ease (though I think it’ll require some custom CSS to make BrewSession look really spiffy on the desktop). I wonder though….what does the general public, the home brewer, think of having to download the AIR runtime in order to run BrewSession? I suppose we need to get a poll going… Feel free to post some opinions…

Concise Signup & Signin Pages

Dean — Mon, 04 Feb 2008 18:16:46 +0000

Login, Signup

We are presented with these quick forms all the time. While it is easy to create standard login and signup pages, Amazon.com has a good one:

What makes it good?

First of all, the prompts are written in plain English. Amazon sells to a wide slice of the population, meaning that about 15% of their customers are probably not very technology-saavy. (-2?) Anything they can do to ease the operation helps their customers buy.

Secondly, when a user visits Amazon.com, there is only one link: “Your account” instead of separate login and signup links. Simple is generally better.

Also note the standard “forgot your password” link plus an additional “has your email address changed?” question. Both are useful to have close at hand.

Implementation

Rails 2.0 strongly encourages you to design RESTful applications. Login forms are associated with Session objects, while signup forms go with User objects (rather, Brewer objects in our case). A simple redirect in the SessionsController#create method takes care of pointing a user in the right direction.

class SessionsController < ApplicationController
def create
if params[:signin_action] == ‘new_user’
redirect_to new_brewer_path( :brewer => {:email => params[:email]} )
else
# Do sigin stuff
end
end
end

Note that we pass params[:email] to the new_brewer_path so that field is automatically populated on the next page. If you are using the generated scaffold, you will have to change your BrewersController#new method to instantiate a new @brewer object:

class BrewersController < ApplicationController
def new
@brewer = Brewer.new(params[:brewer])
end
end

Lastly, here is the extra test:

class SessionsControllerTest < Test::Unit::TestCase
def test_should_redirect_to_new_brewer_if_asked
an_email = "dean@brewsession.com"
post :create, :email => an_email, :signin_action => ‘new_user’
assert_redirected_to new_brewer_path(:brewer => {:email => an_email} )
assert_nil session[:brewer_id]
end
end

In a later post I will talk about how to implement the change password action in a RESTful way.

–Dean

Dean Moves

Dean — Mon, 14 Jan 2008 19:58:34 +0000

My wife got an offer to do her Forensic Entomology PhD at Texas A&M university. It is her dream job to teach and do Forensics work, and since I work from anywhere we packed up and moved to Bryan.

We arrived a week ago, signed a lease, dropped off the dogs and cats and headed to O’Bannon’s, a decent bar that we found during our October visit. It’s nice to be in a place where I can easily get Dogfish Head IPA, but this place does not have the beer diversity of the SF Bay Area. The change in cost of living is awesome though.

What does this mean for Brewsession? Not a heck of a lot. We have always been more of a virtual team that just happened to get together for beer a few times a month. Further, since I have no friends here )-: I can devote more time to coding. I will also do some friend-finding. Danger: the municipal golf course is practically across the street.

Look for a resurgence of development work.

–Dean

It’s oh so quiet… Excuses, and some tidbits about Sessions

gregr — Sun, 09 Dec 2007 22:35:18 +0000

THE EXCUSES: Yes it is quiet. However, that doesn’t mean that nothing it happening. Dean and I are still chugging away on things. “Where’s the promised peek at the calculators?”, you might ask. Well, those are really close now. Seriously. Problem is, we got side tracked in other areas of development, along with the fact that we’ve both been really busy doing other things.

I know, it’s a shame. I wish I had all the time in the world to work on BrewSession™, but as with all of us, I have other work to do that actually pays money. Add to the fact that I just moved, Dean is about to move, I’m taking a few courses at the local college (just for the hell of it) and that spells….”slow progress on BrewSession”.

That being said, it looks like I won’t be so swamped with work in the coming couple months and I’ll have more home improvement projects out of the way. Yeah, I’m just full of excuses. But at least I’m being optimistic.

THE EXCITING STUFF: I’ve been working on “Session” functionality as of late. We’re really excited about the Session screen because it will not only allow you to track and record all the events and measurements during your BrewSession™, but also track everything that happens to your fermented beverage — from brew day to serving the very last pint.

Yup. Track times, temps, gravities, and add notes and more for your mash, pitching the yeast, fermentation, transfers, bottling and kegging, storage, tapping and drinking those bottles. Hey, why not tasting notes too…and why not add notes with a date stamp to track flavor changes over time. In fact, every “event” you add will have a date/time stamp. We’re trying to build in enormous flexibility, so if you can think of it, it’ll be possible (though I’m sure someone’s bound to stump us). You can even set an event before it happens and have an email reminder sent to you on the day the event is set to take place — excellent for remembering to transfer.

You’ll also be able to get a summary of these “events”, in whole or in part. You choose. The ability to accurately track and record all these parameters will allow you to closely compare the same recipe made at different times, showing you which variables changed and allow you to make better guesses on causes for differences in characteristics of the resulting beers. You’ll also be able to quickly tell how long it took you to finish off 10 gallons of that Pale Ale…