I’m making a few changes to my blog. I decided not to split up my blog by different sections. Instead, I will be tagging posts appropriately. In addition I am moving over to Octopress since it seems to make more sense since it won’t have the overhead of a database. Hopefully this gets me to write more often.

Thijs

In Ruby, a string should be converted to an integer in one of two ways:

1
2

some_num.to_i
Integer(some_num)

If we use a normal string representation of an integer (e.g. “123”), both these would seem to act the same. For some string though, they act differently:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# Not a number
"foo".to_i         # => 0
Integer("foo")     # raise ArgumentError: invalid value for Integer: "foo"
"123beer".to_i     # => 123
Integer("123beer") # raise ArgumentError: invalid value for Integer: "123beer"
"abc123".to_i      # => 0
Integer("abc123")  # raise ArgumentError: invalid value for Integer: "abc123"

# Hexadecimal
"0xa".to_i     # => 0
Integer("0xa") # =>  10

# Binary
"0b101".to_i     # => 0
Integer("0x101") # => 5

# Decimal
"0d12".to_i     # => 12 (works same as Integer), "0d12beer123".to_i would also return 12
Integer("0d12") # => 12

# Octal
"0377".to_i     # => 377
Integer("0377") # => 255

Using to_i is better in situations when you only care about the beginning of a string, don’t care about leading zeros, want to return 0 on invalid integers, and the number is represented in decimal (base 10) form. Integer is better in situations where you want to support decimal, binary, octal forms and you want to make sure that an exception is raised if the string passed is not a valid integer.

Similarly, if you are using to_f or Float, to_f will ignore the portion of the string which is no longer numeric (e.g. “3.03beer”.to_f # => 3.03) and return 0.0 while Float will raise an exception if the string has any portion that is not numeric (e.g. Float(“foo”) and Float(“3.03beer”) will raise exceptions). Unlike to_i and Integer, both to_f and Float will ignore leading zeros.

All built in rails validators have access to the interpolations: model, attribute and value. Some validators such as length have access to the count interpolations. These can be used as follows:

1
2
3
4
5
6

class User < ActiveRecord::Base
  validates :username, length: {
    maximum: 25,
    message: "is too large. Expected %{attribute} to be of length %{count} but was %{value}."
  }
end

If a user tries to create a username that is 26 characters they would get the message “Username is too large. Expected Username to be of length 25 but was 26” (note that attribute gets capitalized). This also works when the message is defined from a config/local/*.yml file.

When we write our own validators, it would be nice if we could define our own interpolations. Assume that we are writing a blog and need to validate that there are no duplicate tags passed. If there are duplicate tags, we should display which tags are duplicates. We can wip up a custom validator as follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class NoDuplicatesInListValidator < ActiveModel::EachValidator
  KEY = :duplicates_in_list

  def initialize(options = {})
    options[:message] ||= KEY
    super
  end

  def validate_each(object, attribute, value)
    #find duplicates
    duplicate_hash = value.split.each_with_object(Hash.new(0)) { |item, hash|
      hash[item] += 1
    }
    duplicates = duplicate_hash.select{ |_, v| v > 1 }.keys

    if duplicates.present?
      error_options = {message: options[:message], duplicates: duplicates.join(', ')}
      object.errors.add(attribute, KEY, error_options)
    end
  end
end

The important part here is that when we call object.errors.add, we pass the symbol :duplicates_in_list (it has to be a symbol, else rails will just print out the message interpreted literally with no iterpolations, this also allows other developers to make custom translators using :duplicates_in_list as the key) followed by the option hash with keys :message and :duplicates. The :duplicates key is what essentially holds the custom interpolation. In this case we just pass the array of duplicates and join them with a comma. If we defined the following model:

1
2
3

class Post < ActiveRecord::Base
  validates :tags, no_duplicates_in_list: {message: "has duplicates: %{duplicates}"
end

and try:

1
2
3

t = Tag.new(tags: 'ruby ruby rails jquery')
t.save
puts t.errors.full_messages.join("\n")

we should see the message “Tags has duplicates: ruby”.

ETags are great for keeping the expensive stuff from executing over and over again, for example:

1
2
3
4
5

def some_action
  if stale?(:etag => some_obj, :last_modified => some_obj.created_at, :public => true)
    some_obj.some_really_expensive_operation
  end
end

Will prevents some_really_expensive_operation from executing a second time when the user revisits the page if nothing in the object has changed. This works great on public pages but what if you have some expensive stuff on a page that requires authentication, or a page that the content changes when a user logs in? Fortunately, any object can be passed for the :etag option. We could create a method called authenticated_stale? and include the current user as follows in the application controller as follows:

1
2
3
4
5
6
7
8
9
10
11
12

class ApplicationController < ActionController::Base
  #your code

  def current_user
    @current_user ||= User.find_by_id(session[:user_id]
  end

  def authenticated_stale?(options = {})
    options[:etag] = [options[:etag], current_user]
    stale?(options)
  end
end

And use authenticated_stale? for any page that requires authentication or where the content changes if you are authenticated as you would the stale? method. Make sure not to set the public option true on authenticated pages so they don’t get cached by proxy caches.

Rails three has made it very easy to write custom validators. Ryan Bates has a beautiful example of how to use these validators here (make sure to watch this or read the ascii cast). He uses the following example to illustrate how to create a custom validator for checking the format of an email address:

1
2
3
4
5
6
7

class EmailFormatValidator < ActiveModel::EachValidator
  def validate_each(object, attribute, value)
    unless value =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
      object.errors[attribute] << (options[:message] || "is not formatted properly")
    end
  end
end

This does a good job but is not very useful for an international site. The above code can be rewritten as follows:

1
2
3
4
5
6
7

class EmailFormatValidator < ActiveModel::EachValidator
  def validate_each(object, attribute, value)
    unless value =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
      object.errors.add(attribute, (options[:message] || :email_format))
    end
  end
end

Essentially, we replace the string ‘is not formatted properly’ with the symbol :email_format. This symbol matches the type of validation we are performing.

In addition to this, add the following to the en.yml file of your rails app:

1
2
3
4

en:
  errors:
    messages:
      email_format: "is not formatted properly"

This way you can customize translations not only for the built in rails validators but also custom ones you define yourself.

Feel free to use the code above subject to the following license

Currently I’m working on a project for a company which requires me to be on a VPN in order to access their websites and other resources. I use Cisco VPNClient in order to connect to the IPSec VPN they have. The project requires me to develop an application using Oracle. I am normally a Mac user and Oracle does not supply an OSX version of Oracle XE. My initial solution was to install Oracle XE on an Ubuntu virtual machine which I could than connect to with my Mac. Things were working correctly at first. I pointed my Rails application to the Ubuntu VM’s ip address and was able to connect to the database and run migrations. As soon as I connected to the VPNClient, I was unable to connect to the database using my Mac or network with the Ubuntu VM in anyway. The Ubuntu machine could connect to the internet but any ping I did to it from my Mac timed out.

Upon further research, I found out that VPNClient changes the way networking traffic is routed. Essentially all traffic gets routed to the VPN server that the VPNClient is connected to (I already new this but figured the client would ignore requests to the local network). Knowing that the Ubuntu VM was on a virtual local network I figured enabling ‘Allow Local LAN Access’ would do the trick (you may want to try this solution before taking the steps below). This unfortunately did not solve the problem. Although this option exists, the administrators of the VPN Server can choose to disable this for all users. I tried contacting the administrators and asking if they could enable local networking for me. I was told that it would be impossible to do this without enabling it for everyone and could be a security vulnerability.

I tried changing the routing tables but this too, did not work for me (I might have done it wrong, if this worked for anybody let me know). I also tried connecting to the native Snow Leopard Cisco IPSec VPN. This allowed me to connect to the VPN and connect to my virtual machines but the internet stopped working (I think some of the settings that can be enabled in VPNClient are missing in the Snow Leopard version such as transparent tunneling and using IPSec over UDP).

After reading this article on port forwarding using VMWare Fusion, I wondered if it would be possible to use with the VPN (after all, I’m routing to the localhost, not an external machine). I opened up textmate and opened up the file at:

1

/Library/Application Support/VMware Fusion/vmnet8/nat.conf

I added the following lines:

1
2
3
4
5
6

[incomingtcp]
#192.168.10.3 is the ip I use for my VM
#Oracle Web Admin Page
8080 = 192.168.10.3:8080
#Default Oracle Port
1521 = 192.168.10.3:1521

ran the command:

1

sudo "/Library/Application Support/VMware Fusion/boot.sh" --restart

I opened up a brower on my Mac and typed in ‘http://localhost:8080/apex’ and was presented with the Oracle XE web interface login page. I than connected to the VPN and did the same thing to make sure that it would work over the VPN. After being presented with the login screen a second time I rejoiced a bit, and promptly tried connecting directly to the database with my rails app (had to modify the url of course).

This ended up being a good enough workaround to keep me developing in OSX instead of having to resort to using Windows or Ubuntu for this one job. There are probably better solutions out there which will allow VPNClient to recognize the virtual machines as safe (all the traffic from the VMs also get routed through the VPN if using a NAT connection, I’m not sure about bridged though). The irritating part of this workaround is that you have to specify each port you wish to use and make sure that you set static IPs that match the ports specified in the nat.conf file. If anybody has any better solutions, please respond in the comments section.

For all those who are regulars to this site (all three of you), you may remember my last attempt at making an imperial stout. I revisited the recipe and tweaked it to be a bit less crazy with the flaked barley. The result? A starting gravity of 1.074! This was better than the last time I attempted this and got a starting gravity of 1.060. Still a bit lower than what I had hoped for. I think if I wanna do this right, I’ll need to invest in a bigger kettle and spend more time boiling. Before we get into too much detail, here is the recipe:

13 lbs of Pale Ale Malt 2 lbs of Flaked Barley 1 lb of Roasted Barley 3 oz of Special B 1 oz of Yakima Golding Pellets 1 oz of Cascade Pellets 1 packet of Wyeast Scottish Ale 1728

I essentially collected 8 gallons of wort and boiled down to 5. After an hour of boiling, I added the hops and boiled for another hour. I may go nuts next time and try for 20 lbs of Pale Ale malt and than get two batches running (one imperial, one partigyle pale).

Today I transfered my Pale Ale to the secondary fermentor. I have now been brewing around three years and I’ve become much better at predicting if the beer will taste good from tasting from the hydrometer. I generally move my beers from the primary fermentor to the secondary fermentor after around 1 week. This early in the brewing process, there seems to be a lot of off-flavors in the beer. Almost every off-flavor though seems to go away as the beer matures. I will catalog the different off-flavors that I’ve experienced and situations where they go away, and situations where they stick around. Some “off-flavors” are appropriate for certain styles and to a certain extend, part of brewing beer. They become “off” when the level of these flavors get too high for the style (there will always be some tannins (astringency), diacetyl (buttery) and other flavors in all beers). Off-flavors are often more noticeable in the hydrometer sample than beer since beer is served cold and carbonated while hydrometer samples are taken at room temperature (unless brewing a lager) before the beer is carbonated.

Puckering Bitterness

Puckering bitterness seems to be more prominent in dryer beers and darker beers. It is different than a hoppy bitterness since it usually has your mouth feeling drying than an overly hopped beer. In heavier beers (in terms of ending gravity, not necessarily alcohol) I’ve found this astringency is more palatable since the beer is a tad sweater. With dry beers, I’ve found the astringency will mellow out over time. The roasting process of grain seems to also add some bitterness. This is appropriate for the style generally but will mellow out a bit over time. Puckering bitterness can also be accompanied by a “grainy” flavor since the tannins that cause astringency come form the husks of the grain. Unless the beer tastes more bitter than your average IPA (from astringency, not hops), you will probably be fine. Crash cooling your beer in the secondary can also help the tannins that cause astringency to drop to the bottom of the fermentor.

Sourness

Sourness in very low levels are generally nothing to be worried about, since they tend to mellow out with age. At more noticeable levels, there is the chance that the beer may be infected. That being said, I’ve had beers that tasted a bit sour from the hydrometer sample which tasted fine once they were put in the keg/bottled and carbonated. If you have a very “citrusy” taste to the beer, it can very likely be from the hop flavor. This does mellow out a bit over time and generally is a very mild sourness. I’ve found that very young stouts also have a bit of a sour tinge to them due to the fact that darker grains lower the pH of beer by a small amount. When the sourness starts to taste more like vinegar or sour milk is when you may have a problem. Even in those cases though, wait until the beer is finished before passing judgement on your brew.

Wine/Cidery

A wine like or cider like flavor sometimes presents itself in younger beers. These flavors tend to go away with time. The question boils down to intensity. A mild cider or wine like flavor will mellow out. An intense flavor could mean an infection.

A General “This Tastes Like Cheap Beer” Syndrome

If your beer seems to taste a bit more like cheap beer, but with more flavor, you probably just need to give it more time. Professional breweries generally have a flawless process for making beer. That being said, really cheap beer takes a lot of cost cutting methods, the easiest of which is to reduce the amount of time beer sits in the fermentors. Some commercial beers spend less than a month in the fermentors and thus taste pretty terrible. Obviously, homebrewed beer will have better ingredients than some of the bigger commercial beers, but will still suffer if not given enough time.

The Golden Rule

When brewing, always give your beer enough time to mature before dumping your beer. Unless the beer literally tastes like Satan’s anus, it will probably improve with time. For most beers, after around 2 months, you know what your beer will taste like. Stronger beers will take more time and low gravity beers will take less. Also, less than perfect beer may still be drinkable and you can probably pawn it off one of your friends who appreciated the beer. There are more off flavors than the ones I listed above, but those are the ones I experience the most.

Finally got to brewing again. Decided that since it is getting warm, it’s time to start brewing some pale ales. I like my beers on the hoppy side so this might be on the border of what some would consider a pale ale and others would consider an IPA. The recipe is as follows:

10 lbs of American Pale Ale malt 8 oz of Crystal malt 0.5 oz of 15.8 alpha Warrior for 60 minute addition 0.5 oz of 15.8 alpha Warrior for 15 minute addition 2 oz cascade for dry hop

I mashed with 3.5 gallons of water at 151 degrees for about an hour and 15 minutes. I was a bit worried because the mash took longer than usual to start tasting sweet (I usually taste a bit during my stirrings, which I do every 15 minutes). I’m guessing the American Pale Ale malt is less modified than the Maris Otter malt I usually use. In the end it sweetened right up (I should really do the starch test with iodine, but since I have yet to have issues with full conversion, I never do). I ended up sparging with 6 gallons more of water. After a boil of about an hour and a half, I ended up with 5 gallons of wort with a starting gravity of 1.051. I decided I was going to be happy if I could get it above 1.045 so this is very good news. This beer will be served during the drivers rodeo after party and also during the western mass beerfest I am hosting.

So, all those who know me well, have probably already heard the sad news. The IPA I tried to brew has gone horribly wrong. In essence, do to the large number of hops, I needed something to weigh it down. I was going to go shopping for marbles but could not find any. At the ACME surplus store, I found what I though was stainless steel ball bearings. They were heavy, they were shiny, but they were not stainless steel. Whatever material they were made of, they managed to make the beer smell and taste like brimstone and copper pennies. When I removed the hop bags, the hops were dark brown (they were green when I put them in) and smelled like sea weed instead of grapefruit. The ball bearings were black and corroded and smelled heavily like sulfur. The beer was utterly disgusting to taste. Hopefully my next attempt goes better.