Charles Strahan

No Sound from Headphones on Ubuntu

2011-09-19T04:34:14-07:00

On my Compaq Presario (Model: SR5152NX, Soundcard: ALC888), the audio wasn’t working quite right; when I plugged my headphones in, the audio came out of both the speakers and the heaphones. Here’s how I fixed it.

Finding the Sound Card Model

Issue the following command in a terminal:

head -n 1 /proc/asound/card0/codec*

On my Compaq, that prints “Codec: Realtek ALC888”.

Find the Correct Model Parameter

We’re going to modify /etc/modprobe.d/alsa-base.conf to specify the sound card model, but first we need to know what model parameter we need. Look through the documentation here to find your model:

zless /usr/share/doc/alsa-base/driver/HD-Audio-Models.txt.gz

You’ll find a number of possible settings – you’ll need to pick the closest setting to your hardware. You may need to try a couple by trial and error before you get it just right.

I looked under the ALC882/883/885/888/889 section and tried 3stack-6ch, as I have three ports in the back, and 6 channels per my hardware specs. Unfortunately, that wasn’t quite right, so I tried 3stack-hp instead, which did the trick.

Tweak alsa-base.conf

We must now teak alsa-base.conf:

# Edit the config file:
sudo vim /etc/modprobe.d/alsa-base.conf

# Add the following line to the bottom:
# options snd-hda-intel model=3stack-hp

Et voilã , audio works flawlessly now.

Austin Code Camp 2011

2011-09-12T23:16:16-07:00

It was a pleasure to both attend and speak at Austin Code Camp this year. I couldn’t possibly have had a better response to my first talk, “Seven Soft Skills for Super Sexy Salaries”! If you attended my first talk, thank you so much for all of the positive feedback, and all of the great questions!

Whoops!

Unfortunately, I experienced some technical difficulties whilst giving my second talk, “Let’s create a programming language!”. Because of that, I will be recording and uploading the presentation over the next couple days.

For the curious, ANTLRWorks was invoking javac, which in turn failed with javac: file not found: <path-to-file>. Of course, the file that javac was complaining about was generated by ANTLRWorks and was there, in plain sight. Something was utterly confused. I rebooted and, like magic, ANTLRWorks was working fine…

Note to self: when preparing a presentation, use the same computer you plan to bring with you – crazy shit happens!

The Ubuntu Experience

2011-07-31T16:07:19-07:00

Here are the notes of my attempt to create the ultimate 64-bit Ubuntu 11.04 dev machine, from fresh install to “finish” (as if the tweaking is ever trully finished).

Get Wireless Working

Just after I installed Ubuntu, I noticed that my wireless was acting a little slow. After a little probing, it turned out to be a driver conflict with the default Ralink USB drivers. A quick lsmod | grep rt showed that I had rt2870sta running (which was fine), and then a few other drivers that needed to be blacklisted. I had to append the following to /etc/modeprobe.d/blacklist.conf:

# Get wireless working
blacklist rt2800usb
blacklist rt2800lib
blacklist rt2x00usb
blacklist rt2x00lib

Everything was pretty snappy after rebooting.

UI Tweaks / Hardware Drivers / etc

I mostly followed these two articles immediately after installing Ubuntu:

OpenGL & SDL

Some packages for OpenGL/SDL bindings:

$ sudo apt-get install xorg-dev mesa-common-dev libglu1-mesa-dev \
                       libsdl1.2debian \
                       libsdl1.2debian-alsa \
                       libsdl1.2-dev \
                       libsdl-image1.2 \
                       libsdl-image1.2-dev \
                       libsdl-mixer1.2 \
                       libsdl-mixer1.2-dev \
                       libsdl-net1.2 \
                       libsdl-net1.2-dev \
                       freeglut3 freeglut3-dev \
                       glutg3 glutg3-dev

Adobe Air & Pandora One

I don’t know about you, but I can’t live without Pandora One. Unfortunately, installing Adobe Air on 64-bit Ubuntu wasn’t as easy as I had hoped. You can get it to work with a little finagling though: Install Adobe AIR on 64-bit Ubuntu 10.10.

Exuberant CTags

$ sudo apt-get install exuberant-ctags

(D)VCS

$ sudo apt-get install subversion git-core mercurial

R

$ sudo apt-get install r-base r-base-dev

Java JRE & JDK

See here.

Scala

See here.

Haskell

You should be able to sudo apt-get install haskell-platform, but there was a bug in the package that caused apt-get to fail. Until it gets fixed, take a look here.

Here’s what I did:

$ sudo add-apt-repository ppa:brcha/ppa
$ sudo apt-get update
$ sudo apt-get install haskell-platform

Ruby

I initially installed Ruby via sudo apt-get install ruby, but quickly removed the package in favor of letting RVM handle my rubies through and through. If you’re not familiar with RVM, give this a good read: Ubuntu, Ruby, RVM, Rails, and You.

GNU Smalltalk

Until Ubuntu starts packaging gst again, you’ll need to compile it yourself. Grab the latest version from here (at the time of writing, it was v3.2.4).

To compile:

# Prereqs:
$ sudo apt-get install tcl tcl-dev tk tk-dev

# Compile:
$ wget ftp://ftp.gnu.org/gnu/smalltalk/smalltalk-3.2.4.tar.gz
$ tar xzf smalltalk-3.2.4.tar.gz
$ cd smalltalk-3.2.4
$ autoreconf -vi
$ ./configure

# If ./configure outputs
#   "checking whether to install <SOME_PACKAGE_HERE>... no"
# you'll probably want to see which headers couldn't be found,
# and apt-get the corresponding library before continuing.

$ make
$ sudo make install

Squeak Smalltalk

$ sudo apt-get install squeak-vm

Racket

$ sudo add-apt-repository ppa:plt/racket
$ sudo apt-get update
$ sudo apt-get install racket

MIT Scheme

This site suggests that the following esential and optional packages be installed (respectively):

$ sudo apt-get install m4 autotools-dev libssl-dev libncurses5-dev libx11-dev libxt-dev libltdl-dev
$ sudo apt-get install libmhash-dev libmcrypt-dev libgdbm-dev libpq-dev libdb-dev

Then download and compile:

$ wget http://ftp.gnu.org/gnu/mit-scheme/snapshot.pkg/20090107/mit-scheme-c-20090107.tar.gz
$ tar xzf mit-scheme-c-20090107.tar.gz
$ cd mit-scheme-c-20090107/src
$ etc/make-liarc.sh
$ sudo make install

CLISP

$ sudo apt-get instal clisp

SBCL

$ sudo apt-get instal sbcl

Erlang

See this gist/script.

MongoDB

$ sudo apt-key adv --keyserver keyserver.ubuntu.com --recv 7F0CEB10
$ sudo nano /etc/apt/sources.list
$ echo "deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen" | sudo tee --append /etc/apt/sources.list
$ sudo apt-get update
$ sudo apt-get upgrade
$ sudo apt-get install mongodb-10gen

Programming Environments

I installed Eclipse, Netbeans and Emacs from the Software Center. Vim and IntelliJ IDEA were a little more involved, though.

Installing IntelliJ IDEA

See here.

Installing Vim

I wanted a decent Vim will all the bells and whistles, including Command-T. Ubuntu has a package for Vim, but it’s a little flakey with Ruby extensions (it was at the time wrote this, anyway). Here’s (more or less) everything I needed to get a big fat vim compiled and installed from source.

# Vim dependencies:
$ sudo apt-get install libncurses5-dev libgnome2-dev libgnomeui-dev \
  libgtk2.0-dev libatk1.0-dev libbonoboui2-dev \
  libcairo2-dev libx11-dev libxpm-dev libxt-dev

# Language bindings:
$ sudo apt-get install python python-dev lua5.1 luarocks perl libperl5.10

# Compile:
$ hg clone https://vim.googlecode.com/hg/ ~/vim
$ cd ~/vim
$ hg update -C v7-3-154
$ ./configure --with-features=huge \
            --enable-perlinterp --enable-pythoninterp \
            --enable-rubyinterp --enable-gui=gnome2 \
            --disable-largefile \
            --enable-luainterp=dynamic
$ make
$ sudo make install

# If you get "Terminal entry not found in terminfo 'gnome-256color'" in terminal vim,
# you'll want this:
$ sudo apt-get install ncurses-term

Dotfiles

After installing my favorite apps, I needed to get my dotfiles from my Windows box copied over. This presented a bit of a problem, considering how I had my dotfiles stored in git: all files were in the root, which meant that I had to clone the repo directly into my home folder. I settled on creating a dedicated ~/.dotfiles folder to host my dotfiles, each of which would then be symlinked into ~/ via a Rakefile. Whenever I get around to customizing my bash, I’ll throw in a script to recursively load my scripts.

You can take a look at my Rakefile and dotfiles here.

Mongoid + YAML + Rails = Conflict

2011-05-14T18:58:06-07:00

The Problem

You get the following when you try to run your Rails app with Mongoid:

db_name must be a string or symbol
C:/Ruby192/lib/ruby/gems/1.9.1/gems/mongo-1.3.1/lib/mongo/util/support.rb:50:in `validate_db_name'

The Cause

You probably have RubyGems v1.5.0, which changes the default yaml parser to psych (as opposed to syck), which doesn’t like :<< in yaml files.

The Solution

Add the following to the top of your config/environment.rb:

require 'yaml' 
YAML::ENGINE.yamler= 'syck'

… or perhaps you could just tweak your YAML to make psych happy. I don’t know what-the-hell I’m doing, so I took the easy way out.

Feel free to share better alternatives.

Credit

Thanks go to the chaps on this Mongoid forum thread.

Alt.Net Seattle 2011

2011-05-08T17:35:42-07:00

This year’s Alt.Net Seattle conference was a blast. I met and mingled with so many bright developers over the short span of four days. The collective passion and energy was absolutely overwhelming.

Oh, and thank you GitHub & Bookr for the drink-up – you guys rock!

Vim Tweaks on Windows

2011-04-30T23:12:14-07:00

To be frank, getting vim and Windows to play nice is a bit of a pain in the ass. Here are some tips and tricks to get the most out of vim on Windows.

Power Tools

If you want a pretty slick setup without too much hassle, check out Fabio Akita ‘s vimfiles. Here’s a list of some of the bad-ass plugins that I find particularly useful (full list can be found on the GitHub repo):

fugitive
Command-T
surround
rails

Make it Sexy

I absolutely love the Solarized theme. If you use Akita’s vimfiles, you already have it installed (courtesy of yours truly).

Here are a couple other cosmetic changes from my .vimrc:

if has("gui_win32") || has("gui_win32s")
  set guifont=PragmataPro:h10
  set background=dark
  colorscheme solarized
endif

" Taggle Solarized light/dark background using F5 key
call togglebg#map("<F5>")

" No space between lines
set linespace=0

" Make csharp code use 4 spaces for tabs
autocmd FileType cs setlocal expandtab shiftwidth=4 softtabstop=4

If you don’t already own a copy, go buy PragmataPro – thine eyes shalt thank thee.

Visual Studio

Add gVim as an external tool. Go to Tools > External Tools > Add and plug in the following:

Title: &Vim
Command: C:\Program Files (x86)\Vim\vim73\gvim.exe
Arguments: --servername VimualStudio --remote-silent +"call cursor($(CurLine),$(CurCol))" $(ItemPath)
Initial directory: $(SolutionDir)

By specifying --servername VimualStudio, you’ll have a dedicated vim process just for Visual Studio.

Fixing Problems

Here are some problems I came across. If you have any of the following problems, see if the given solution will work for you.

#1 – CommandT::VIM Conflicts with ::VIM

line 74
NoMethodError: undefined method `command' for CommandT::VIM:Module

Solution: See this page for help.

#2 – CommandT Crashes Vim

Solution: Following the advice here solved my problem. It appears that there’s a bug in vim that was patched as of version 7.3.088.

You may also have to build CommandT. To do so, you’ll need to have the Ruby DevKit installed. Then, enter the following in shell (change the paths to reflect your system):

c:\RubyDevKit\devkitvars.bat
cd C:\Users\Charles\vimfiles\bundle\Command-T\ruby\command-t
ruby extconf.rb
make

#3 – Fugitive’s GDiff Fails

Error detected while processing function <SNR>12_BufReadIndexFile..<SNR>12_ReplaceCmd:
line  26:
E302: Could not rename swap file
Press ENTER or type command to continue

Solution: One of the answers on this StackOverflow question should do the trick.

#4 – Mysterious Blank Screen

If you have a blank screen until you press a key, vim probably ran into a problem and displayed a warning. In my case, I needed to tell CSApprox to shut up:

" Put this at the very top of your .vimrc:
let g:CSApprox_verbose_level=0

Anything Else?

If there’s something that you think I’m missing, let me know!

From Wordpress to Jekyll

2011-04-20T22:00:00-07:00

I’ve finally decided to ditch Wordpress for Jekyll. I really don’t see the point in using a full-fledged blogging platform if you’re seasoned developer — there’s just way too much bloat to sift through.

How is this any better?

What do I like about it? Well, it’s pretty easy to get started (aside from seting up Pygments on Windows)¹, and all of my posts are contained in textile formatted files — for example, this here is the textile file for this very page. Of course, all of my posts are version controlled using Git, and my site is built and hosted on GitHub.

Dude, I’m sold!

Sweet! Here are some tips for you after you’ve installed Jekyll.

Autogenerate New Posts

Make a rake task to generate new posts, and include a unique identifier. This will be used by Disqus and the

Configure an Atom Feed

Checkout my atom feed for inspiration. Note the use of post.uuid, which we auto-generated with our rake task. I use FeedBurner to keep track of my following.

Use Disqus

Use Disqus for your comments and be sure to use your posts’ uuid, just in case your URLs change (the UUID will assosciate your posts with your comments). You can check out my post template here.

¹ You’ll find a guide here for getting Pygments installed on Windows.

² BTW, Jekyll 0.11.0 has some trouble with textile on Windows.

Adventures in .NET - Aspect Oriented Programming

2010-09-29T22:20:54-07:00

About this Series

“Adventures in .NET” is a series of articles that aim to expose .NET developers to powerful techniques and concepts to empower them to develop software more productively. The concepts that I present in this series have been gleaned from years of designing and implementing software solutions, and I hope to save you hours of frustration by helping you avoid the pitfalls I experienced through the application of these powerful patterns and practices. While I won’t dive too deep into each subject, I do hope to inspire you to both learn and incorporate these technologies into your work.

All source code for this series can be found on GitHub here:
http://github.com/cstrahan/adventures-in-dotnet

The Problem

As software developers, it is a well known (not to mention begrudging) fact that we spend most of our time maintaining code; anything that we can do to minimize the amount of time spent in “maintenance mode” is a major boon to both our productivity and our esteem, and that entails writing less code in the first place. Unfortunately, there is another well known fact that conspires against our productivity; our codebases tend to be littered with eerily similar code that we just can’t seem to abstract out. An excellent example of this problem is present in any class that implements INotifyPropertyChanged (INPC); every property requires an explicit getter and setter, and the setter must notify the subscribers of the appropriate changes; a perfect example of a DRY violation:

public class PersonViewModel : INotifyPropertyChanged  
{  
    public event PropertyChangedEventHandler PropertyChanged;  
  
    private string _firstName;  
    public string FirstName  
    {  
        get  
        {  
            return _firstName;  
        }  
        set  
        {  
            _firstName= value;  
            RaisePropertyChanged("FirstName");  
        }  
    }  
  
    private string _lastName;  
    public string LastName  
    {  
        get  
        {  
            return _lastName;  
        }  
        set  
        {  
            _lastName= value;  
            RaisePropertyChanged("LastName");  
        }  
    }  
  
    protected void RaisePropertyChanged(string propertyName)  
    {  
        if (PropertyChanged != null)  
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));  
    }  
}

Polymorphism is great for abstracting out vertical commonality (all objects within a type hierarchy share the same traits; a dog is an animal); however, OOP doesn’t provide us with a solution for abstracting out the horizontal aspects (e.g. INPC, logging all method invocations, auditing changes to Entities, etc). What we need is a means to abstract out the common aspects of our objects’ functions; this is where Aspect Oriented Programming (AOP) steals the lime light.

Solutions

While C# as a language doesn’t provide any syntactic means for applying AOP (unlike some languages, such as as AspectJ), we do have several options at the CLR level: proxies (dynamic/remote) and post-compile static IL-weaving. We’ll take a look at each of these in turn.

Dynamic Proxies

A dynamic proxy class is a class that implements a list of interfaces specified at runtime such that a method invocation through one of the interfaces on an instance of the class will be encoded and dispatched to another object through a uniform interface. Thus, a dynamic proxy class can be used to create a type-safe proxy object for a list of interfaces without requiring pre-generation of the proxy class, such as with compile-time tools.
(http://download.oracle.com/javase/1.4.2/docs/api/java/lang/reflect/Proxy.html)

A dynamic proxy class may be thought of as a decorator class that is emitted at runtime; you must make all of your intercepted methods and properties abstract or virtual if you wish for the generated class to derive from your target class (a class proxy), or you may specify an interface for the generated class to impliment (an interface proxy), in which case you may leave your members non-virtual. There are two excellent .NET libraries that help in constructing dynamic proxies: Castle’s DynamicProxy and LinFu. While both are great libraries, let’s take a look at Castle’s DynamicProxy.

DynamicProxy supports both class proxies and interface proxies, which are created through the instance methods of the ProxyGenerator class. The ProxyGenerator constructs proxies that delegate control to a list of one or more IInterceptors that you provide. Let’s take a look at the definition for the IInterceptor interface:

public interface IInterceptor  
{  
    void Intercept(IInvocation invocation);  
}

All of the magic happens inside of the Intercept method; it provides you with all of the info regarding the current method invocation in the aptly named invocation argument, and it allows you to handle the invocation as you see fit. You can proceed with the invocation by calling invocation.Proceed, inspect the arguments with invocation.Arguments, view the MethodInfo via invocation.Method, etc. In our case, we will use this as an opportunity to encapsulate our aspects.

For those familiar with dynamic languages, this is akin to having Ruby’s method_missing within a static type system; the difference is that we can only intercept methods that are defined on our proxy class.

That’s enough theory; let’s take a look at a concrete example (heavily inspired by this post from Sebastien Lambla’s blog):

public class PersonViewModel : INotifyPropertyChanged  
{  
    public event PropertyChangedEventHandler PropertyChanged;  
    [Notify]  
    public virtual string FirstName { get; set; }  
    [Notify]  
    public virtual string LastName { get; set; }  
}  
  
public class NotifyAttribute : Attribute { }  
public class NotifyPropertyChangedInterceptor : IInterceptor  
{  
    public void Intercept(IInvocation invocation)  
    {  
        // let the original call go through first, so we can notify *after*  
        invocation.Proceed();  
  
        if (invocation.Method.Name.StartsWith("set_"))  
        {  
            string propertyName = invocation.Method.Name.Substring(4);  
            var pi = invocation.TargetType.GetProperty(propertyName);  
  
            // check that we have the attribute defined  
            if (Attribute.GetCustomAttribute(pi, typeof(NotifyAttribute)) == null)  
                return;  
  
            // get the field storing the delegate list that are stored by the event.  
            FieldInfo info = invocation.TargetType.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)  
                .Where(f => f.FieldType == typeof(PropertyChangedEventHandler))  
                .FirstOrDefault();  
  
            if (info != null)  
            {  
                // get the value of the field  
                PropertyChangedEventHandler evHandler = info.GetValue(invocation.InvocationTarget) as PropertyChangedEventHandler;  
                // invoke the delegate if it's not null (aka empty)  
                if (evHandler != null)  
                    evHandler.Invoke(invocation.TargetType, new PropertyChangedEventArgs(propertyName));  
            }  
        }  
    }  
}  
  
static void Main(string[] args)  
{  
    var proxyGenerator = new ProxyGenerator();  
  
    PersonViewModel personViewModel = proxyGenerator.CreateClassProxy<Personviewmodel>(new NotifyPropertyChangedInterceptor());  
  
    personViewModel.PropertyChanged += (src, prop) => Console.WriteLine(prop.PropertyName);  
  
    personViewModel.FirstName = "Charles";  
    personViewModel.LastName = "Strahan";  
}

As you can see, we’ve made the code simpler while also making our intent much more clear – a win/win result.

If you want a more detailed look at DynamicProxy, look no further than Krzysztof Kozmic’s excellent tutorial. Likewise, there is an excellent tutorial for LinFu on CodeProject by Philip Laureano – LinFu’s author.

Remote Proxies

The .NET remoting infrastructure can be used to intercept method invocations by hooking into the message sink chain, allowing us to apply our aspects. We’ll use a custom IMessageSink implementation to intercept messages to our remote proxy:

using System;  
using System.ComponentModel;  
using System.Linq;  
using System.Reflection;  
using System.Runtime.Remoting.Messaging;  
  
namespace RemoteProxy  
{  
    public class AutoNotifySink : IMessageSink  
    {  
        private readonly MarshalByRefObject _target;  
  
        public AutoNotifySink(MarshalByRefObject target, IMessageSink nextSink)  
        {  
            _target = target;  
            NextSink = nextSink;  
        }  
  
        public IMessageSink NextSink { get; private set; }  
  
        public IMessage SyncProcessMessage(IMessage msg)  
        {  
            var returnedMessage = (IMethodReturnMessage)NextSink.SyncProcessMessage(msg);  
            TryRaisePropertyChanged((IMethodMessage)msg);  
            return returnedMessage;  
        }  
  
        public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)  
        {  
  
            throw new InvalidOperationException();  
        }  
  
        private void TryRaisePropertyChanged(IMethodMessage methodMessage)  
        {  
            if (methodMessage.MethodName.StartsWith("set_"))  
            {  
                var propertyName = methodMessage.MethodName.Substring(4);  
                var type = Type.GetType(methodMessage.TypeName);  
                var pi = type.GetProperty(propertyName);  
  
                // check that we have the attribute defined  
                if (Attribute.GetCustomAttribute(pi, typeof(NotifyAttribute)) != null)  
                {  
                    // get the field storing the delegate list that are stored by the event.  
                    FieldInfo info = type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)  
                        .Where(f => f.FieldType == typeof(PropertyChangedEventHandler))  
                        .FirstOrDefault();  
  
                    if (info != null)  
                    {  
                        // get the value of the field  
                        var handler = info.GetValue(_target) as PropertyChangedEventHandler;  
  
                        // invoke the delegate if it's not null (aka empty)  
                        if (handler != null)  
                            handler.Invoke(_target, new PropertyChangedEventArgs(propertyName));  
                    }  
                }  
            }  
        }  
    }  
}

Now that we have a custom a custom message sink, we’ll need some way to specify that this message sink should be used:

using System;  
using System.Runtime.Remoting.Activation;  
using System.Runtime.Remoting.Contexts;  
using System.Runtime.Remoting.Messaging;  
  
namespace RemoteProxy  
{  
    public class AutoNotifyContextProperty : IContextProperty, IContributeObjectSink  
    {  
        public string Name  
        {  
            get  
            {  
                return "AutoNotify";  
            }  
        }  
  
        public bool IsNewContextOK(Context ctx)  
        {  
            return true;  
        }  
  
        public void Freeze(Context ctx)  
        { }  
  
        public IMessageSink GetObjectSink(MarshalByRefObject obj, IMessageSink nextSink)  
        {  
            var notifySink = new AutoNotifySink(obj, nextSink);  
            return notifySink;  
        }  
    }  
  
    [AttributeUsage(AttributeTargets.Class)]  
    public class INPCAttribute : ContextAttribute  
    {  
        public INPCAttribute()  
            : base("INPCAttribute")  
        {  
        }  
  
        public override void GetPropertiesForNewContext(IConstructionCallMessage ctor)  
        {  
            IContextProperty notifyProperty = new AutoNotifyContextProperty();  
            ctor.ContextProperties.Add(notifyProperty);  
        }  
    }  
}

Now we just apply that attribute like so:

using System;  
using System.ComponentModel;  
  
namespace RemoteProxy  
{  
    [INPC]  
    public class PersonViewModel : ContextBoundObject, INotifyPropertyChanged  
    {  
        public event PropertyChangedEventHandler PropertyChanged;  
        [Notify]  
        public string FirstName { get; set; }  
        [Notify]  
        public string LastName { get; set; }  
    }  
}

As you can see, this was relatively straightforward. One of the nice things about this implementation is that we don’t need to explicitly wrap the target class in proxy – it’s all transparent. However, this does require that we inherit from ContextBound object, and the performance is considerably lower than with the dynamic proxy.

Post-Compile Static IL-Weaving

IL-weaving is another approach to AOP in .NET. Instead of trying to intercept messages via proxies, a second step can be added to the build process that “weaves in” the necessary IL into the emitted assemblies.

Jb Evain’s Mono.Cecil library is excellent for manipulating IL; when combined with a custom build task, it can make for an excellent AOP tool (Justin Angel has an excellent tutorial). The only down side to using Mono.Cecil is that you have to manipulate the individual IL opcodes (Cecil is meant for generic IL manipulation). Alternatively, If you have some money to spare, PostSharp is an excellent product that takes much higher-level approach to IL-weaving, providing an API similar to DynamicProxy’s IInterceptor.

For the sake of brevity, I won’t be including any code samples for this approach.

Conclusion

AOP is a powerful technique that, when used appropriately, can greatly simplify your projects. Common activities such as logging, auditing and caching can all be abstracted away using the aforementioned techniques. I encourage you to consider how these techniques can be applied to your current project(s). If you have any questions, please feel free to email me at charles.c.strahan gmail.com.

Setting an SSH Key's Password

2010-06-03T21:50:11-07:00

This was a royal pain in the ass to figure out, so hopefully this’ll save you or someone else some time. What follows is pretty much copied verbatim from the following site:
http://www.noah.org/wiki/SSH_public_keys

Note to Windows/msysgit users: the following commands will work without a hitch if you run them from the “GIT Bash”. Otherwise, you’ll need to ensure that openssl is on your PATH. I’m assuming here that your key is located at %userprofile%/.ssh/id_rsa.

Unencrypt your existing key

If your existing key is encrypted (read: has a password), you’ll need to remove the encryption first (this will obviously overwrite the existing key file):

openssl rsa -in ~/.ssh/id_rsa -out ~/.ssh/id_rsa

Encrypt your existing key

Once you’ve unencrypted your key, you’ll need to re-encrypt it (this will obviously overwrite the existing key file):

openssl rsa -des3 -in ~/.ssh/id_rsa -out ~/.ssh/id_rsa

When you run the above command, you’ll be prompted for your new password.

Linq in IronRuby

2010-04-26T21:28:05-07:00

Perusing through some old IronRuby mailing lists, I saw some people inquiring about using Linq from IronRuby. The general response was that it wasn’t necessary – you can use the equivalent methods on the Enumerable module. That works fine if your working with an IEnumerable, but there’s one big problem – you can’t consume an API that exposes an IQueryable without calling #to_a. That sucks because you’re now eager-loading everything into RAM. C# devs have the benefit of lambda expressions, but there isn’t an equivelent in Ruby. You could create an Expression tree manually, but that sucks even harder.

That’s way to much suckage going on – now lets make it blow! Er, suck less:

require 'System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089'  
require 'System.Linq.Dynamic'  
  
# Add DynamicQueryable methods to IQueryable[T]  
System::Linq::IQueryable[1].module_eval do  
  dynamic_methods = %w{ any count group_by order_by select skip take where }  
  dynamic_methods.each do |method|  
    define_method("dynamic_#{method}") do |*args|  
      System::Linq::Dynamic::DynamicQueryable.method(method).call(self, *args)  
    end  
  end  
end  
  
# Add some usefull methods to ::Enumerable and IEnumerable  
enumerables = [Enumerable, System::Collections::IEnumerable]  
enumerables.each do |enum_module|  
  enum_module.module_eval do  
    def as_queryable  
      System::Linq::Queryable.as_queryable(self)  
    end  
  
    def cast(type)  
      System::Linq::Enumerable.method(:cast).of(type).call(self)  
    end  
  end  
end  
  
# Check it out!  
nums = [1,2,3,4,5,6,7,8,9]  
p nums.cast(Fixnum) \  
      .as_queryable \  
      .dynamic_where("it % @0 == @1", 2, 0) \  
      .to_a  #=> [2, 4, 6, 8]

What’s going on here?

First off, I’m using the DynamicQueryable class that comes packaged as an example solution with Visual Studio 2008. I compiled the project as a class library, output as System.Linq.Dynamic.dll (thus the require 'System.Linq.Dynamic').

Next, you’ll see that I’m dynamically defining methods on IQueryable<T> that delegate to System.Linq.Queryable. I create a list of the Queryable static method names that I want to include, loop over each, and use Module#define_method to create the method.

Lastly, I add #as_queryable and #cast methods to ::Enumerable and IEnumerable, just for convenience.

It’s not quite as nice as C#, but I’m sure it could get there with some lovin’. Next on my “todo” list is to write an example of using this technique with Linq-to-SQL, with some metaprogramming sprinkled on top. I’ll present a couple things here in a little while:

Write a DSL for Linq-to-SQL mappings.
Get active_record-esque ease of use with Linq-to-SQL. Just load a DBML file – no need for code generation.
Even better active_record-ness. Same as above, with the benefit of using just a connection string.

ASP.NET Development Server v2.0 - Faster, Better, Stronger

2010-03-09T21:54:40-08:00

So here’s the thing – we all hate having to tie our Visual Studio solutions to an IIS web site when the ASP.NET Development Server will do just fine. Sure, it’s best to test our web apps on a live, flesh and blood IIS server – but for small scale projects, why bother? You and I are happy to use it 99% of the time…

… but some times we can’t!

That’s right – ASP.NET Development Server refuses remote connections. What’s an iPhone web app developer to do? Use IIS so I can establish remote connections from my iPhone?

Hell no!

Ladies and gentlemen, I present to you: ILDASM

Ohhhh yeah! It’s time to bring out the big guns. We’re gonna have us a little hackin’ action. If the dev server doesn’t want to play nice, we’ll make it!

Step 1: Let’s grab the dev server executable. You can find out where it’s located by debugging a ASP.NET web project, opening the Task Manager and clicking the “Open File Location” on the WebDev.WebServer.EXE. Copy that file to c:\temp, where we’ll do a little patch work later on. In my case, it’s in the following folder: C:\Program Files (x86)\Common Files\microsoft shared\DevServer\10.0

Step 2: It’s time to perform open heart surgery. Grab Reflector, and let’s get to work. Drag and drop the executable onto Reflector and take a look around. You’ll notice that there’s nothing of real interest here – it delegates most of the heavy lifting to the WebDev.WebHost40 assembly. Let’s figure out where that is like so:

Now that we know where it is, let’s copy that to c:\temp:

xcopy C:\Windows\Microsoft.Net\assembly\GAC_32\WebDev.WebHost40\v4.0_10.0.0.0__b03f5f7f11d50a3a\WebDev.WebHost40.dll c:\temp

Step 3: Back to Reflector! Let’s take a look around for a sec… Did you notice the Request class? Let’s take a look there. Ah! Request.Process() looks rather suspicious:

[AspNetHostingPermission(SecurityAction.Assert, Level=AspNetHostingPermissionLevel.Medium)]  
public void Process()  
{  
    if (this.TryParseRequest())  
    {  
        if (((this._verb == "POST") && (this._contentLength > 0)) && (this._preloadedContentLength < this._contentLength))  
        {  
            this._connection.Write100Continue();  
        }  
        if (!this._host.RequireAuthentication || this.TryNtlmAuthenticate())  
        {  
            if (this._isClientScriptPath)  
            {  
                this._connection.WriteEntireResponseFromFile(this._host.PhysicalClientScriptPath + this._path.Substring(this._host.NormalizedClientScriptPath.Length), false);  
            }  
            else if (this.IsRequestForRestrictedDirectory())  
            {  
                this._connection.WriteErrorAndClose(0x193);  
            }  
            else if (!this.ProcessDefaultDocumentRequest())  
            {  
                this.PrepareResponse();  
                HttpRuntime.ProcessRequest(this);  
            }  
        }  
    }  
}

Hmmm… that call to TryParseRequest()… let’s take a look:

private bool TryParseRequest()
{  
    this.Reset();  
    this.ReadAllHeaders();  
    if (!this._connection.IsLocal)  
    {  
        this._connection.WriteErrorAndClose(0x193);  
        return false;  
    }  
    if (((this._headerBytes == null) || (this._endHeadersOffset < 0)) || ((this._headerByteStrings == null) || (this._headerByteStrings.Count == 0)))  
    {  
        this._connection.WriteErrorAndClose(400);  
        return false;  
    }  
    this.ParseRequestLine();  
    if (this.IsBadPath())  
    {  
        this._connection.WriteErrorAndClose(400);  
        return false;  
    }  
    if (!this._host.IsVirtualPathInApp(this._path, out this._isClientScriptPath))  
    {  
        this._connection.WriteErrorAndClose(0x194);  
        return false;  
    }  
    this.ParseHeaders();  
    this.ParsePostedContent();  
    return true;  
}

Busted! If the connection is not local, return a 403 and close the connection – WriteErrorAndClose(0×193). Let’s put this on our naughty list – we’ll get back to it later on.

Step 4: Hunt down the Loopbacks! Here’s Server.Start():

public void Start()  
{  
    try  
    {  
        this._socket = this.CreateSocketBindAndListen(AddressFamily.InterNetwork, IPAddress.Loopback, this._port);  
    }  
    catch (Exception exception)  
    {  
        SocketException exception2 = exception as SocketException;  
        if ((exception2 != null) && (exception2.SocketErrorCode == SocketError.AddressAlreadyInUse))  
        {  
            throw exception;  
        }  
        this._socket = this.CreateSocketBindAndListen(AddressFamily.InterNetworkV6, IPAddress.IPv6Loopback, this._port);  
    }  
    if (this._socket != null)  
    {  
        ThreadPool.QueueUserWorkItem(this._onStart);  
    }  
}

Those Loopbacks gotta go.

Step 5: It’s surgery time. Use ILDASM to dump WebDev.WebServer.EXE and WebDev.WebHost40.dll to c:\temp\server\WebDev.WebServer.IL and c:\temp\host\WebDev.WebHost40.IL, respectively. When prompted, tick each checkbox on the output options.

Let’s start with the host. Open up WebDev.WebHost40.IL, preferably with a real text editor. Let’s first find those Loopbacks – locate the Server.Start() method:

  .method /*0600009B*/ public hidebysig instance void
          Start() cil managed
  // SIG: 20 00 01
  {

Now, replace Loopback and IPV6Loopback with Any and IPV6Any, respectively. In other words, this:


becomes:

<pre class="console"
IL_0003:  /* 7E   | (0A)0000A4       */ ldsfld     class [System/*23000003*/]System.Net.IPAddress/*01000015*/ [System/*23000003*/]System.Net.IPAddress/*01000015*/::Any /* 0A0000A4 */

Great! Now it’ll accept connections – but it will still respond with a 403 and drop the connection – no bueno! Let’s fix it.

Here’s the offending code:

if (!this._connection.IsLocal)  
{  
    this._connection.WriteErrorAndClose(0x193);  
    return false;  
}

That translates to the following IL (from the TryParseRequest() method):

    IL_000c:  /* 02   |                  */ ldarg.0
    IL_000d:  /* 7B   | (04)00004E       */ ldfld      class Microsoft.VisualStudio.WebHost.Connection/*02000004*/ Microsoft.VisualStudio.WebHost.Request/*0200000B*/::_connection /* 0400004E */
    IL_0012:  /* 6F   | (06)000015       */ callvirt   instance bool Microsoft.VisualStudio.WebHost.Connection/*02000004*/::get_IsLocal() /* 06000015 */
    IL_0017:  /* 2D   | 12               */ brtrue.s   IL_002b

                                         // this._connection.WriteErrorAndClose(403); return;
    IL_0019:  /* 02   |                  */ ldarg.0
    IL_001a:  /* 7B   | (04)00004E       */ ldfld      class Microsoft.VisualStudio.WebHost.Connection/*02000004*/ Microsoft.VisualStudio.WebHost.Request/*0200000B*/::_connection /* 0400004E */
    IL_001f:  /* 20   | 93010000         */ ldc.i4     0x193
    IL_0024:  /* 6F   | (06)000023       */ callvirt   instance void Microsoft.VisualStudio.WebHost.Connection/*02000004*/::WriteErrorAndClose(int32) /* 06000023 */
    IL_0029:  /* 16   |                  */ ldc.i4.0
    IL_002a:  /* 2A   |                  */ ret

    // blah blah blah . . .

Pretty simple, right? If the connection is local, branch – go to IL_002b and continue processing. There’s several ways you can fix this – my suggestion is that you just replace the “this._connection.WriteErrorAndClose(403)” code with NOPs. Here’s what you end up with:

    IL_0019:   nop
    IL_001a:   nop
    IL_001b:   nop
    IL_001c:   nop
    IL_001d:   nop
    IL_001e:   nop
    IL_001f:   nop
    IL_0020:   nop
    IL_0021:   nop
    IL_0022:   nop
    IL_0023:   nop
    IL_0024:   nop
    IL_0025:   nop
    IL_0026:   nop
    IL_0027:   nop
    IL_0028:   nop
    IL_0029:   nop
    IL_002a:   nop

Yay! One last little change:

.assembly /*20000001*/ WebDev.WebHost40
{
  // blah blah blah
  .ver 10:0:0:0 // Let's bump this up to .ver 10:1:0:0
}

Now, create a strong name key using Sn.exe. After you have your snk, compile the IL using:

ilasm /dll /resource=webdev.webhost40.res /key=c:\temp\mykey.snk webdev.webhost40.il

Install the assembly into the GAC:

gacutil /i c:\temp\webdev.webhost.dll

One assembly down, one more to go; we still need to update the web server’s reference to the new WebDev.WebHost40. Open up WebDev.WebServer40.IL and change this:

.assembly extern /*23000005*/ WebDev.WebHost40  
{  
  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )  
  .ver 10:0:0:0  
}

.assembly extern /*23000005*/ WebDev.WebHost40  
{  
  .publickeytoken = (00 00 00 00 00 00 00 00 ) // put _YOUR_ public key here!!!  
  .ver 10:1:0:0  
}

Now it’s time to compile using ilasm:

ilasm /exe /resource=WebDev.WebServer40.res /key=c:\temp\mykey.snk WebDev.WebServer40.il

Give it a test:

c:\temp\server\WebDev.WebServer40.exe /port:1234 /path:c:\path\to\website /vpath:website [/ntlm]

You’re golden, Ponyboy! Create a backup folder in your DevServer\10.0 folder, then feel free to replace the original executable with your patched version.

Why Combinators? (pun intended)

2010-01-24T20:46:06-08:00

Y indeed!

“What is a fixed-point? What is the fixed-point Y combinator? How can we utterly abuse the aforementioned concepts for fun and profit?”

If you’re interested in delving into such Functional Programming topics, this blog post is for you. I would like to note, however, that ML programmers can skip this entire post and read That About Wraps it Up by Bruce J. McAdam, which serves as the inspiration for much of this post; if you’re a C# person, such as myself, you’re in the right place.

Note: You’ll find the related code on GitHub here.

What’s in it for me?

Functional Programming is a bit mind bending for the uninitiated, so before we commit to anything, let’s take a look at what we will gain by delving into this esoterrorism.

The rent complexity is too… damned… high!

Let’s take a look at a (naïve) implementation of a Fibonacci number generator:

Func<int, int> fib = null; fib = n => n < n ? n : fib(n-2) + fib(n-1);

While that works, it has some rather fundamental flaws:

fib closes over itself, which can lead to some very strange issues.
It’s slower than snot.

The first problem becomes apparent when do something like the following:

Func<int,int> fib = null;  
fib = n => n < 2 ? n : fib(n-2) + fib(n-1);  
  
Console.WriteLine(fib(6)); // displays 8  
  
var fibCopy = fib;  
fib = n => n * 2;  
  
Console.WriteLine(fibCopy(6)); // displays 18!

The problem that we’re seeing here is that fib is not really recursive, as it does not inherently invoke itself – it just invokes whatever function is bound to the variable fib.
The second problem is a little more pronounced. Go ahead and invoke fib(2000)…

… assuming you’ haven’t died of old age, let’s consider some solutions. If we could wrap the recursive definition of fib such that the result of each computation was cached, we would have a much more efficient Fibonacci number generator without having to change our original definition (a technique called Memoization). Ideally, we should be able to do something as simple as follows (excepting some funky syntax):

var fib = Lambda.Functional<BigInteger, BigInteger>(fibo => n => n < 2 ? n : fibo(n - 1) + fibo(n - 2))  
                .Memoize()  
                .Fix();  
  
Console.WriteLine(fib(2000));  
/* displays: 
42246963333923048787067256023414827825798528402506810980102801373143085843701307 
07224123599639141511088446087538909603607640194711643596029271983312598737326253 
55580260699158591522949245390499872225679531698287448247299226390183371677806060 
70116154978867198798583114688708762645973690867228840236544222952433479644801395 
15349562972087652656069529806499841977448720155612802665404554171717881930324025 
204312082516817125 */

Guess what? By the time you’ve finished reading this, we will have implemented that very same code. If your interest is piqued, you’ll probably enjoy the rest of this post; otherwise, this just might bore you to death.

Fixed-point whatsits

Fixed-point combinators are at the heart of the magic that we’re going to perform. But before I scare you away with my academic vocabulary, let’s break this down into several bite sized, tasty concepts. First, a definition of fixed point is in order. A fixed point of a function f is a value x such that f(x) = x. In graphical terms, this is any point where y=x. While this isn’t horribly interesting to us when f is a function of simple types (integers and such), it is much more exciting when we consider higher order functions.

To find the fixed point of a higher order function, we need something called a fixed-point combinator. A combinator is a function with no free variables, and a fixed-point combinator is a function g such that g(f)=p, where p is the fixed point. As it turns out, this is well charted territory; perhaps the most well known fixed-point combinator, Haskell Curry’s Y combinator, is defined as follows:

Y = λf.(λx.f (x x)) (λx.f (x x))

While Y works well in the untyped lambda calculus, we’ll run into some problems if we try to make a straight port to C#; C# is evaluated in applicative order, and thus Y would result in infinite series of invocations. Also, we’d have to define some clever self-applicable delegate types to make the compiler happy. We’ll look at two implementations – one that stays fairly true to the Y combinator, and another much simple example that cheats by using C#’s syntactic support for recursion.

Let’s Fix it

First, how can we define a recursive function without explicitly referring to itself? Well, we could require that the function be passed in like so, yielding the function that we want:

Func<Func<int, int>, Func<int, int>> fib = fibo => n => n < 2 ? n : fibo(n-2) + fibo(n-1);

… but what exactly are we supposed to pass in?

We need the fixed-point – where the same function going in is the same function coming out. Because the resulting function (n => n < 2 ? n : fibo(n-2) + fibo(n-1)) references the function coming in (fibo), the fixed-point would be the recursive function we are after.

Here’s the easy way out:

public static Func<T1, TReturn> Fix<T1, TReturn>(Func<Func<T1, TReturn>, Func<T1, TReturn>> functional) {  
    return functional(a1 => Fix(functional)(a1));  
}  
  
var fib = Fix<int, int>(fibo => n => n < 2 ? n : fibo(n-2) + fibo(n-1));  
Console.WriteLine(fib(6)); // displays 8

Note that we are recursing by calling Fix within the lambda; while that works, that isn’t quite true to the original Y Combinator. Let’s take a look at the Y Combinator again:

Y = λf.(λx.f (x x)) (λx.f (x x))

And here’s a C# rendition:

public delegate TResult SelfApplicable<TResult>(SelfApplicable<TResult> r);  
  
public static Func<T1, TReturn> Fix<T1, TReturn>(Func<Func<T1, TReturn>, Func<T1, TReturn>> functional) {  
    return new SelfApplicable<Func<T1, TReturn>>(  
        r => a => functional(r(r))(a))(r => a => functional(r(r))(a));  
}  
  
// ... we can make that a little more concise using the U combinator, which applies a given function to itself:  
  
public static TResult U<TResult>(SelfApplicable<TResult> r) {  
    return r(r);  
}  
  
public static Func<T1, TReturn> Fix<T1, TReturn>(Func<Func<T1, TReturn>, Func<T1, TReturn>> functional) {  
    return U<Func<T1, TReturn>>(r => arg1 => functional(U(r))(arg1));  
}

Time to wrap it up

Now that we have a fixed-point combinator, we can pull off some interesting tricks by wrapping the original function using some reusable combinators. I promised that I’d show you how to write a memoizing combinator, so lets take a look at that now:

public static Func<Func<T1, TReturn>, Func<T1, TReturn>> Memoize<T1, TReturn>(Func<Func<T1, TReturn>, Func<T1, TReturn>> functional) {  
    var cache = new Dictionary<T1, TReturn>();  
    Func<Func<T1, TReturn>, Func<T1, TReturn>> wrapper =  
        f => arg1 =>  
        {  
            TReturn result;  
            if (!cache.TryGetValue(arg1, out result))  
            {  
                result = cache[arg1] = functional(f)(arg1);  
            }  
  
            return result;  
        };  
    return wrapper;  
}  
  
Func<int, int> fib =  
    Fix(  
        Memoize<int, int>(  
            fibo => n => n < 2 ? n : fibo(n-2) + fibo(n-1)));

That’s pretty cool… but why stop there? Let’s write a tracing wrapper and compare the memoized fib function against the unadulterated version:

// Utility method, to allow for type inference.  
public static Func<func<T1, TReturn>, Func<T1, TReturn>> Functional<T1, TReturn>(Func<Func<T1, TReturn>, Func<T1, TReturn>> functional) {  
    return functional;  
}  
  
public static Func<Func<T1, TReturn>, Func<T1, TReturn>> Trace<T1, TReturn>(this Func<Func<T1, TReturn>, Func<T1, TReturn>> functional) {  
    var recursionLevel = 0;  
    Func<Func, <T1, TReturn>, Func<T1, TReturn>> wrapper =  
        f => arg1 =>  
                    {  
                        recursionLevel++;  
  
                        var indent = new string(' ', recursionLevel*2);  
                        Console.WriteLine(indent + arg1);  
  
                        TReturn result = functional(f)(arg1);  
  
                        recursionLevel--;  
  
                        return result;  
                    };  
    return wrapper;  
}  
  
var fastFib = Functional<int, int>(fibo => n => n < 2 ? n : fibo(n-2) + fibo(n-1))  
             .Trace()  
             .Memoize()  
             .Fix();  
  
Console.WriteLine("fib({0}) = {1}", 8, fastFib(8));  
  
/* OUTPUT: 
  8 
    7 
      6 
        5 
          4 
            3 
              2 
                1 
                0 
fib(8) = 21 
*/  
  
// (Notice that we're not memoizing here)  
var slowFib = Functional<int, int>(fibo => n => n < 2 ? n : fibo(n-2) + fibo(n-1))  
             .Trace()  
             .Fix();  
  
Console.WriteLine("fib({0}) = {1}", 8, slowFib(8));  
  
/* OUTPUT: 
  8 
    7 
      6 
        5 
          4 
            3 
              2 
                1 
                0 
              1 
            2 
              1 
              0 
          3 
            2 
              1 
              0 
            1 
        4 
          3 
            2 
              1 
              0 
            1 
          2 
            1 
            0 
      5 
        4 
          3 
            2 
              1 
              0 
            1 
          2 
            1 
            0 
        3 
          2 
            1 
            0 
          1 
    6 
      5 
        4 
          3 
            2 
              1 
              0 
            1 
          2 
            1 
            0 
        3 
          2 
            1 
            0 
          1 
      4 
        3 
          2 
            1 
            0 
          1 
        2 
          1 
          0 
fib(8) = 21 
*/

Functional… or dysfunctional?

How practical is any of this? Well, I’m not really sure. The fact that you can “hook into” a recursive algorithm using some simple, reusable combinators is rather fascinating. On the other hand, I’d be a little worried using this in production; the lack of tail-call optimization combined with each wrapper invocation will result in a StackOverflowException in a hurry. With that said, I do believe that this exercise has given me new insights into FP and programming patterns in general, so I’d consider it a win.

ODBC via Ruby on Windows

2009-06-03T21:38:29-07:00

I just got Ruby to connect to a database via ODBC and the dbi gem (particularly, MSSQL). I ran into a few problems along the way, so here are some of my notes.

DBI

Make sure you have the dbi and dbd-odbc gems installed:

gem install dbi 
gem install dbd-odbc

Next, you’ll want to make sure that you have the odbc.so and odbc_utf8.so files in your Ruby installation (check your lib\ruby\1.8\i386-mingw32 folder). If you do not have these, go grab i386-msvcrt-ruby-odbc.zip from here:

http://www.ch-werner.de/rubyodbc/

You can now use dbi like so:

require 'rubygems'  
require 'dbi'  
  
DBI.connect('DBI:ODBC:test_dsn') do | dbh |  
  dbh.select_all('select * from sys.tables') do | row |  
      p row  
  end  
end

ActiveRecord

You can also use active_record. First, go grab odbc-rails from here:

http://odbc-rails.rubyforge.org/

If you go to the download page, you’ll see that there are two versions: 1.5 and 2.0 for Rails 1.x and 2.x, respectively. Doing a gem install odbc-rails resulted in 1.5 being installed on my machine, so I downloaded the “activerecord-odbc-adapter-2.0.gem”http://rubyforge.org/frs/download.php/35985/activerecord-odbc-adapter-2.0.gem file from rubyforge and installed that. Once you’ve installed the gem, you can follow the instructions on the odbc-rails homepage to use it from Rails, or you can use some code like the following if you want to use active_record outside of a Rails project:

require 'rubygems'  
require 'active_record'  
  
ActiveRecord::Base.establish_connection(  
  :adapter  => "odbc",  
  :dsn      => "test")  
  
class Person < ActiveRecord::Base  
end  
  
p Person.find(:all)

Note: If you’re connecting specifically to SQL Server, it’s probably a better idea to use the activerecord-sqlserver-adapter gem. Here’s a good link on that topic:

http://rubyrailsandwindows.blogspot.com/2008/03/rails-2-and-sql-server-2008-on-windows_24.html

Alternatives

There are also a few other alternatives. Check these out: