Aaron Maenpaa

Commuting in Victoria

This summer I'm participating in Extreme Blue which is an internship program where a team of students collaborate with experienced IBM engineers and managers to produce high value technology. The teams attempt to bring innovative solutions to real business problems. All in all it's pretty exciting.

I'm working with an IBM team based in Victoria, BC which is quite removed from my current home: Ottawa. While I'm in Victoria, I'm staying in one of the UVic residences, which presents a bit of a challenge in terms of commute. I don't have a car, it's a little far to walk which leaves taking the bus or getting creative. Since I'm not overly fond of relying on taking the bus, last weekend I picked up a bicycle at a local bike shop and have started commuting by bicycle.

My new bike. It's grey and not particularly exciting.

Now that I've got a bike, I have to find a route to and from work that I'm happy with. The first is 7.8 km and dead simple. I take one of the main roads leading away from the university (Mackenzie) and follow it until I hit a second major road (Quandra), which I follow north until I get to work. While direct, this route has substantial traffic, intersections and inconsistent bike lanes that make it less than pleasant.

The direct, though not particularly pleasant route from the University of Victoria to the IBM campus.

While, the second route under consideration is slightly longer, 10.8km, and not quite as dead simple to follow, it takes the rider along the ocean and through Mt. Douglas Park while subjecting them to less traffic and controlled intersections. While, the second route is unmistakably nicer, I'm not sure I'm up to handling the marginal 3.0km. Maybe as I get back into the habit of cycling, I'll consider taking the route through the park, particularly on a leisurely bike home.

The more pleasant, though slightly longer route from UVic to IBM.

Next week is Bike to Work Week, so I'll be practicing my commuting skills and planning to hit up at least a few of the celebration stations throughout the week. At the very least I'll be hitting up the wrap-up barbecue.

Munchkin Mayhem

With Statement (Redux)

My previous implementation of the with_statement in ruby had one major flaw: It allowed only a single context manager per with block. While effective, it leads to cluttered code, like the following:

with(open("hello.txt")){|f|
    with(open("bonjour.txt")){|g|
        puts f.read()
        puts g.read()
    }
}

Effective, but it isn't as clear as it could be and introduces more nesting than is really necessary. This coupled with my desire to explore varargs methods and blocks in ruby has lead me to a more robust implementation that can take an arbitrary number of managers as a parameter.

def with(*managers, &block)
    def with_(managers, resources, block)
        if managers.nitems > 0
            begin
                resource = managers.delete_at(0)
                resources << resource.enter()
                with_(managers, resources, block)
            ensure
                resource.exit()
            end
        else
            block.call(*resources)
        end
    end

    with_(managers, [], block)
end

The preceding implementation is more complex than the original. In addition to introducing "star magic"1, it relies on recursive creation of begin-ensure blocks which complicates exception handling; however, this implementation allows for such beautiful usage as:

with(open("hello.txt"), open("bonjour.txt")) {|f, g|
    puts f.read()
    puts g.read()
}

Should a manager's exit method raise an exception, that exception will supersede any exception raised within the block, though it will not interfere with exiting other managers.

An implementation and unittests are available in a Mercurial repository. The implementation can be retrieved as follows:

hg clone http://hg.crimzon.ath.cx/with_statement

Both the implementation and unittests are licensed under the MIT license.

With Statement in Ruby

One of the things that I do enjoy about Ruby is the ability to use blocks to synthesize control structures that may be missing. For instance, I'm a big fan of python's with statement. Through a combination of guerilla patching and blocks, the with statement can easily be added to the ruby language as a library.

require 'thread'

class Mutex
    def enter
        lock
    end

    def exit
        unlock
    end
end

class IO
    def enter
        return self
    end

    def exit
        close
    end
end

class ContextManager
    def enter
    end

    def exit
    end
end

def with(resource)
    begin
        yield(resource.enter())
    ensure
        resource.exit()
    end
end

This implementation allows for such beautiful usage as:

require 'thread'
require 'with_statement'

with(File.open("hello.txt")) {|f|
    puts f.read()
}

lock = Mutex.new
with(lock){
    puts "Yay! Synchronized!"
}

Constructor Ideas

public class Thing{
        private final int id;
        private final String name;
        private final boolean unique;

        public Thing(int id, String name){
                this.id = id;
                this.name = name;
                this.unique = false;
        }

        public Thing(int id, String name, boolean unique){
                this.id = id;
                this.name = name;
                this.unique = unique;
        }
}

public static class Thing{
        private final int id;
        private final String name;
        private final boolean unique;

        public Thing(int id, String name, boolean unique){
                this.id = id;
                this.name = name;
                this.unique = unique;
        }

        public Thing(int id, String name){
                this(id, name, false);
        }
}

public class Thing{
        private int id;
        private String name;
        private boolean unique;

        public Thing(){}

        public void setId(int id){
                this.id = id;
        }

        public void setName(String name){
                this.name = name;
        }

        public void setUnique(boolean unique){
                this.unique = unique;

        }

        public static void main(String[] args){
                Thing thing = new Thing(){{
                        setId(1);
                        setName("Aaron");
                        setUnique(true);
                }};
        }
}

public class Thing{
        private final int id;
        private final String name;
        private final boolean unique;

        public Thing(int id, String name, boolean unique){
                this.id = id;
                this.name = name;
                this.unique = unique;
        }

        public static void main(String[] args){
                Thing thing = new Thing(1, "Aaron", true);
        }
}