Articles tagged 'programming'

Hot Routes Feb 10

Last day or so I’ve come up against a couple of intriguing Rails problems while trying to knock up some plugins for an app I’m writing. I’ll write up the second of the two problems later, but here goes the first…

Put simply, I wanted to define a route within my plugin. My plugin implemented a controller (and also contained a view for that controller, see one of the latest features to hit edge Rails ahead of Rails 2.0).

I searched to try and see if anyone had come up against a similar task, but didn’t see any concrete answers. My testing led me to realise that every time a call to ActionController::Routing::Routes.draw is made, it completely clears and re-generates routes based on the block passed to that method. So simply calling draw with a new block containing my required route wouldn’t work; it’d overwrite other routes, or end up getting overwritten by other routes later in the chain.

I then figured it was time to get cracking with some meta-programming, and that I was going to have to re-define and extend the draw method in order to be able to map the routes I want, and do it in a way that’d be flexible and fair to the original Rails routes file, and other plugins that wanted to toy around with routing. I came up with the following:

module ActionController
    module Routing
        class RouteSet
            alias draw_old draw
            def draw
                draw_old do |map|
                    map.connect "controller/action", :controller => "mycontroller", :action => "myaction"
                    yield map

Let’s give this a quick run-through… I’m re-opening the ActionController::Routing module, and specifically the RouteSet class where the draw method exists. I’m using alias to copy the existing draw method to a method name “draw_old”, before re-defining the draw method itself. Within my version of the draw method, I’m calling the old one and passing it a block that firstly defines the routes I wanted to add to the application, and that then yields the appropriate mapper object back to any block passed in to the draw method itself. Dependent on where you want your route to appear in the scheme of things, you could always map your plugins custom routes after you yield the mapper to the calling block, so that they appear after any other routes. Another tweak would be to alias the existing draw method to something like “draw_old_APPNAME”, where APPNAME is the name of your application. This would ensure that if multiple plugins implemented something similar, that they then wouldn’t clash.

There may be a better way to tackle the problem, but after half an hour of working the problem over (mad props to my boy Mike for helping me tweak the solution into something useful and re-usable), I think I came up with a pretty solid answer, and with a bit more time, something that could probably be wrapped up into a module or plugin all of its very own. Bottom line? Ruby as a language rocks, the dynamic nature and meta-programming features opens whole new doors of functional programming to me, and I’m having to really think outside of the box to see some of the amazing things you can do with it.


Debuggering Feb 5

This is a pretty nice idea, and looks like a really useful tool. It’s in a fairly early stage, but it is shaping up to be quite nice. Think I’ll grab it, take a look, and see if I can help out somehow…


Mac Daddy Sep 24

So I’ve recently got a MacBook Pro, and it’s fucking awesome. For a start, it’s quick, and secondly, I’m finally, after numerous attempts in the past, enjoying the Mac OS X experience. I’m not sure what it is this time around, but I think working on a Mac just feels right in laptop form. I’m running Parallels for all my Windows needs (damn you, VS2005 and C#), and while I’m tempted to also give Boot Camp a go for the gaming aspects (have you seen Company of Heroes? and apparently HL2 runs real nice on the MBP too!), for now I’m sticking with the virtualisation solution.

But I’m also learning TextMate, and man oh man is that a sweet program to use. I’m a little overwhelmed by all the add-ins (sorry, bundles) and shortcuts there are, but at least it’s prettier than emacs :-)


RubySharp Aug 22

Recently I’ve been toying with John Lam’s pet project, RubyCLR. The very notion of Ruby and C# interaction interests me, as there are around a billion different situations in which I’d like to combine the two, to get the best of both worlds.

Now, I notice in a post today, that he has spotted that Tim Ng, a guy who works on the Visual Basic compiler team, has been playing with his creation. Only, the way he went about it seemed a little complex, and wasn’t using RubyCLR’s compatibility with interfaces to the max. So, I thought I’d outline a little test scenario I knocked up when I first started playing with it.

I’ll assume that you’ve followed the instructions, and are setup with the latest version of RubyCLR (I was using the code straight from the source tree).

Firstly, the code for the C# side of things (the “host”). This defines the interface, and provides a class for executing implementations of the interface:


using System;

public interface IAddIn
string Name { get; }
string Author { get; }
void Work();

public class Host
public static void Execute(IAddIn addin)
Console.WriteLine("[{0}] : {1} by {2}",

We can simply compile this into a standalone assembly:

csc -t:library Host.cs

This will output Host.dll, which we will now consume in our super-duper Ruby script, empowered by the magic RubyCLR. I won’t stick the entire contents of the client Ruby script here, however the full thing is available from here (the full C# source file from above is available here). For now, lets just look at the implementation of our C# written interface within Ruby:

class MyAddIn
implements IAddIn

def get__name
return "My first Ruby/.Net add-in!"

def get__author
return "El Draper"

def work
puts "This is coming straight from my Ruby written add-in!"

As you can see, in order to implement the Name and Author properties, we define Ruby methods called get__name and get__author (note the double underscore).

This is all useless unless within my Ruby script I actually call my C# host and pass an instance of my Ruby written add-in. After referencing the Host.dll assembly:

reference_file ‘Host.dll’

I’m able to make the call to the host:


Running this is then easy - once you’ve executed the “setenv.cmd” batch file within the root of the RubyCLR project, simply execute:

ruby Client.rb

(ensuring that Client.rb and Host.dll reside in the same directory).

This then outputs:

[T32dda3e3] : My first Ruby/.Net add-in! by El Draper

This is coming straight from my Ruby written add-in!

(N.B. the type name changes each and every time the script is run, as the concrete wrapper type created around the Ruby code and passed through onto the CLR is dynamically generated at run-time using System.Reflection.Emit).

The above shows that we can define an object that implements a .Net interface within Ruby, and then pass an instance of this into a .Net written host class. It then executes methods directly on the object that itself then executes Ruby code. Pretty snazzy eh!

Like Tim, I have a number of things I’d like to be able to extend this with. For one, I’d like to be able to “compile up” the concrete CLR types representing Ruby objects, and then execute this from within a .Net host, namely a C# application. My work on tweaking the RubyCLR code so far has resulted in being able to correctly output the dynamically generated assemblies, however these types when executed within a C# host application result in memory errors, presumably because it is lacking the reference to the Ruby host context and the original Ruby source file. So I need to be able to instantiate a Ruby object from my compiled emitted assembly, and then somehow build a Ruby context back to the original source file so it can correctly execute the code, but all from within a .Net host. This is really a reverse of the main scenario that RubyCLR I think was probably invented for, but none-the-less I think it should be possible. Any ideas, John? ;-)

Technorati Tags: , , , , , , ,



My first real contribution to project RIDE-ME, the add-in architecture, is now in the trunk of the source tree. Check it out, comment, submit patches or let me know feedback. I’m pretty pleased with it, and it should foster some nice add-in development hopefully :-)


For all these times, that we walked away Jul 14

Bit of a catch-up here, as it’s been far too long since I blogged:

  • England are out, and the World Cup is over. The first event left me feeling raw anger towards the Portuguese (who over the years have given me plenty to be pissed about). The second was a rather bittersweet event. On the one hand, I’d far rather see neither France nor Italy win it, but out of the two I would have to have reluctantly picked the aging French surrender monkeys, rather than the greasy match-fixing Italians, to have won it. But the Zidane incident made the entire thing worthwhile, it was pure enjoyment seeing him getting his marching orders, with the classic shot of him leaving the field yards away from the World Cup trophy, combined with the fact than an Italian was for once legitimately polaxed.
  • I got me SkyHD installed, and it is sw-eeeet. I can now watch HD sporting events, movies, and other assorted goodies (including alsorts of random documentaries, which I’d never usually watch except for the fact that it’s in HD). The box itself is sleek and chic, and bar a couple of random lock-ups last couple of days, has behaved excellently for a first generation piece of equipment. Oh, and the Sky+ PVR system is fantastic, I forgot how much I missed being able to setup entire series to be recorded with a couple of remote clicks.
  • I’m wrapping up the add-in architecture for RIDE-ME. I hope to have it in my branch by the end of this weekend, and then merge it over after then to trunk. We can then test the hell out of it, while the other guys start to write whatever add-ins they can dream up. Eventually, in the 1.0 release, it’ll see the light of day, and we hope to build a nice add-in community around it. Oh, and I’m now hosting all of the resources for the RIDE-ME project.
  • Did I mention HD? I’m currently watching Die Hard With A Vengeance apparently in HD (didn’t even realise HD cameras were around back in ‘95), and Bruce Willis never looked so good.
  • I’ve been having a lot of fun with the object/relation mapping framework I’m working on at the minute, integrating it tightly with the model-view-controller framework I knocked together. It’s starting to come together, and I’ve just implemented associations in queries (read: joins). I’ve got a reason for putting all of this together, and that reason is almost ready for the big-time, so watch this space…
  • I’ve ordered a SleepTracker watch, but there’s no stock at the minute so I gotta wait.
  • The new Rise Against album is fantastic, along with the latest albums from Billy Talent and Lostprophets, expect reviews soon
  • RubyCLR is superb, I think John Lam might be a genius
I think that’s mostly it believe it or not, so peace out for now.


DotNetKicks... Jun 28

is a Digg like clone, centered around .Net content. Useful resource for .Net developers.

Technorati Tags: , , , , ,


Get offensive like Tet Jun 28

Interesting article from Ted Neward, starting with an interesting analogy, segwaying into a brief history of the Vietnam war, and ending up with the crux of the article being about object/relational mapping, the black art of mapping objects to relational database tables. Interesting concepts and ideas, I’m still reading and digesting much of what the article has to say.

While I’m linking like a link-whore this evening, DHH finally blogs about his ActiveResource sweetness committed to the Rails trunk the other day. His post includes the slides from RailsConf, and the entire concept sparks a load of potential ideas off with me.

Technorati Tags: , , , , , , ,


Plug In Baby Jun 27

Here’s a good post from Phil Haack about plugins, and making a plugin architecture resilient to versioning. He presents some good ideas, some stuff worth thinking about in there. I’m thinking about and working on plugins loads at the minute, including working on an add-in architecture for Project RIDE-ME. Reading this post though made me start to question some of the terminology, where a lot of the time I’m using “plugin” out of context. The way I now see it, there are plugins, add-ins, and providers. I’m about to refactor a bit of code I’ve been working on, as it is effectively a provider system, for database and logging providers, however I’ve referred to it throughout as plugins, and I feel this is now slightly out of context…

Plugin: something fairly generic, to be able to “plug in” new components to change almost any aspect of an application
Add-in: something that is contained, used more within rich user interfaces to provide a specific bit of UI content or functionality, much more refined than a general purpose plugin
Provider: some kind of general functionality such as data querying, logging, that can be achieved against different sources, hence the need for differing providers

This is now how I’m starting to formalize some of the terms above, and while almost all of the reflection code remains the same regardless, the design of the architecture depends heavily
on which of the above you are trying to achieve.

Technorati Tags: , , , , , ,


Rail Riding Jun 9

So I came across what looks to be a nice little Windows based Ruby on Rails IDE - RIDE-ME. It’s written in .Net which is cool, and while still in its early phases, seems to be looking quite nice. Also, they are looking for C# developers to join the fold and help out, so with my experience in C# programming, and my almost unhealthy interest in Ruby and Rails, I feel compelled to contribute!

Haven’t posted much recently, but there’s a few things I’ve got that I want to post when I got more time, so hopefully over the coming weekend I’ll get it done.

Technorati Tags: , , , , , , ,


Stacked Actors Apr 25

So, day two of the UML course, and it’s starting to get useful. Use cases, leading on to class diagrams, has me intrigued as a coder. I want to get cracking now trying it out on a system I’m designing (designing before coding, wowee!), but upon looking for some decent UML software, preferably a plug-in for VS 2005, I’m most disappointed. Now I understand VS 2005 has some class diagram tools built-in, but while it looks like UML, it doesn’t smell quite like UML (am I missing something?). I really want something that lets me create any of the different types of UML diagrams (such as use case, class diagrams etc), however the only software I’ve so far come across (such as Borland’s Together plug-in for VS 2003/2005) costs a shitload of money. So, I’m going to keep digging, but my options look limited…

1) personal, “free but only for non commercial” or trial versions - basically yucky cut-down tools
2) NetBeans 5, or at least the latest alpha/beta whatever, seems to have some UML diagramming tools - but come on, a different IDE just for diagrams?
3) a separate tool, such as an open source tool - again, I’d prefer it within my main IDE, but oh well…. *sigh*

Anyone have any ideas? As some may have guessed, this is one of the reasons I quickly cobbled together the ability to add basic comments again tonight, benching all of the big ideas I’ve got for my blogging software in favour of quickly deploying a way for my loyal readers (both of you, including that Google search bot) to post any suggestions they may have!

More UML tidbits soon hopefully…

Technorati Tags: , , , , ,


Fragile Development Apr 24

Today I did a bit of modelling - data modelling that is. I started my five-day UML course, as I’m attempting to learn the deadly art of analysis. It was actually quite interesting - after Getting Real recently (must get round to finishing that book) I was starting to dispense more with documentation/design diagrams and all that in favour of writing the damn code. However there are times when I need to crystallize my thoughts, gather design details, and really plan more complex concepts. It seems after today that UML, and design analysis, is a good way of doing that. In many ways, the course I’m doing (which is actually object-oriented design and analysis, specialising in UML) does tie in with a few agile concepts - in particular, the idea of smaller iterations of development, and an especially agile process for coping with design/requirement changes. On top of this, the idea of use cases defining functionality, doubling up nicely as easy scenarios for testing, ties in with test-driven development. So while I initially poo-poo’d heavy-handed design, analysis, and UML, I’m finding it refreshing to look at a project from a far more architectural point-of-view - especially when the model-view-controller pattern was brought up as being a Good Thing ™ - something I’ve spent a lot of my spare time working on recently. Over-all: interesting stuff, and expect a few more thought provoking posts (with hopefully even more amusing titles).

Technorati Tags: , , , , , , ,


Page 1 of 2 | Next page