I got back from Build on a high that I've not felt since ... gee, since I started going to these tech event things.

It was a pleasure to be at a conference so chock full of fantastic speakers. Meyer, Miner, Sims, Budd, Boulton and Van Damme — these guys are a good cross section of the kind of guys leading the web today.

Not only that, but I was so proud that the event was hosted by Andy McMillan. Andy's work to raise the profile of himself and his peers in Ireland is relentless and admirable. Build 2010 is already announced, but I'm hoping his eye will turn to the international scene, because it's obvious that he has what it takes. It's all the more pleasing that Andy's not a social media witch doctor nor is he an SEO magnate, nor does he list his number one skill as "connecting like-minded people".

Andy's a down to earth, honest to goodness, passionate web designer. And it shows. Build is probably the most relevant web conference ever held in Ireland. Others, take note.

I just had an awesome latté. I don't think it was too different from other lattés I've had. It's a rotten day in Dublin, so that might have added to it, but I think the real reason is this:

I've been drinking a lot of black coffee lately. I've found that black coffee is quite difficult to drink. Like any fine food or drink though, the more you drink, the more you appreciate it.

I enjoyed the latté more because I've been pushing my palate with stronger, ultimately more rewarding, but harder to drink stuff. I remember when I didn't enjoy lattés but kept drinking them until I did.

I've found that this is a common theme. Something that's tough at the beginning gets easier, and it's really easy to appreciate how far you've come by doing the things you used to find hard. It's important to keep pushing the limits.

I decided to sign up for the RubyConf 5k as I'll be there in November and I wanted a way to motivate myself to run more.

I told a friend yesterday that I was doing it, and I mentioned to him that early on I was having difficulty running long distances, because I'd get really tired out after just a few minutes. But then one day I started out real slow, increasing the pace bit by bit and now I find that I can go on much longer without stopping.

"Paul", he said, "It's called 'Pacing Yourself'"

I've been checking lots of form fields for a blank value (eg. they contain nothing, or just whitespace) lately, and I wanted to emulate Rails' String#blank? to check this in jQuery.

I had been doing something like this:

if($.trim($(this).val()) == '') ... 

But that's so ugly I felt there must be a better way. Of course, there is:

if($(this).is(':blank')) ...

Simple, clear, and jQuery-ish.

Update This technique, while awesome, isn't bundled with jQuery and requires the jQuery validation plugin (docs). Paul Campbell tag:www.pabcas.com,2009:81 2009-09-29T08:08:50Z 2009-09-29T08:08:50Z

It installed dozens of crufty extensions, looked just awful, and ran with the pluck and elegance of an incontinent grizzly bear with the gout.

Great piece using Adobe's growing path into unreliable bloatware, and the elegance of small apps that do one or a few things really well.

most software managers are under-staffed (see below), overworked and/or under-qualified. They would rather let the group deal with Asshole Architect, Mr. Stinky or Jimmy the office jerk than to go around provoking difficult conversations and making more work themselves

Say what you like about Obie Fernandez, he knows the industry inside out. Entertaining and insightful.

Danny Kirwan didn't last much longer in Fleetwood Mac, but I think this song will be with me for a long time

Watch, and shiver

ActiveRecord string interpolation. Nom.

Post.all(:conditions => ['date <= :today', {:today => Date.today}])

I've been following a really simple pattern for organising controllers in Rails lately and it's helped me to simplify my controllers and write code that's nice and specific to certain contexts. I refer to it as the "Home / Dashboard / Admin Dashboard" pattern.

The pattern basically follows from the question "Who's looking at this controller?" ... and typically there will be three main users: anonymous users, logged in users and admin users. Given that their concerns when using an app and the various resources in that app will all be different, the trick is to create three namespaces.

Basically, the first page that an anonymous user will see, and subsequently the map.root, will be a singleton resource "home" ... mapped to home_controller. Next, when a user logs in, they get their own area, within their own namespace, something like "my" and they get their logged in singleton resource "dashboard" ... mapped to dashboard_controller. Finally, an admin user will have the option to log in to an "/admin" area and their own dashboard.

Following this, I now have logical namespaces to put any further controllers. If, for example, I have a model named "Post", I put a posts_controller in each of the namespaces, "/", "/my" and "/admin". This leaves me with three distinct areas that have their own permissions, context and views. I find it a really neat way to keep my controllers lean within particular context. It also helps me to only write code specific to those contexts in views.

Here's the routes file that would make this happen:

ActionController::Routing::Routes.draw do |map|
  
  map.root :controller => "home", :action => "show"

  map.resources :posts
  
  # Logged in user routes
  map.namespace :my do |my|
    my.dashboard :controller => "dashboard", :action => "show"
    my.root :controller => "dashboard", :action => "show"
  end
  
  # Admin Routes
  map.namespace :admin do |admin|
    admin.dashboard :controller => "dashboard", :action => "show
    admin.root :controller => "dashboard", :action => "show"
    admin.resources :posts
  end
end

With the pattern, each of the posts_controllers only need to have actions and code specific to each context: eg. the anonymous one need only have index and show code, because anonymous users will never be updating posts.

On the flipside, the admin version can have full permissions, and the logged in user can have granular access control. Cool, clean separation of intent in each context.

What if, in Rails, when building an XML API you wanted to output something like this:

<posts>
  <post>
    <id>1</id>
    <url>http://www.pabcas.com/posts/1</url>
  </post>
</posts>

As of Rails 2.3, there's not really a neat way to do this, using ActiveRecord's to_xml serialization. I needed this functionality today and stumbled across a patch that's been accepted for Rails 3. It will allow something like:

wants.xml { render :xml => @posts.to_xml(:procs => [Proc.new {|options,post| post_url(post) }]) }

Delicious! Bring on Rails 3!

Check out the Lighthouse ticket and the patch.

Great piece from the Times in 2005 reflecting on Disney's purchase of the rights to Henson's Muppets. I've been watching the show lately and am completely enamoured. I love the hidden imagery of what you don't see: the muppeteers themselves:

Of course, the possibility of a culture clash between Disney and the Muppets always seemed quite obvious. Until recently, let us not forget, Disney would not employ anyone with a beard at its theme-parks. One look at any picture of Jim Henson and the 1970s creative nebulous of The Muppet Show, on the other hand, reveals a group of hairy hippies, most of whom look like Robinson Crusoe at Day 405 on Treasure Island

Jaw droppingly beautiful "blogazine" with magazine like typesetting and compelling content.

You should follow me on twitter here and check out Dustin's site here.

I've been watching "The Muppet Show" season one lately, and found it to be a stellar education in show business. I've only known about two of the first nine stars, but upon Googling, they certainly are mega-stars.

I was particularly taken by Charles Aznavour's performance of Inchworm, from the Hans Christian Andersson movie. Moving stuff.

Strict rules around phone upgrades have never really bothered me in the past, as I'm usually due an upgrade around the time I go looking for a new phone.

Not so with the iPhone on O2 Ireland. I started a thread on their "discussion" forum and after initially being shot down by "support" staff, the thread got some good replies, particularly in relation to just how many operational "rules" a customer must "break" just to get an iPhone at all.

Sometimes, you have a field on an ActiveRecord Rails model that stores a URL. The user might enter "http://" or they might not. I had this problem, solved it for one model, then needed it for another one. It's plugin baby time!

So I made the world's simplest URL field plugin

Just throw the "url_field" into your class:

class Company
  url_field :website
end

@company = Company.new
@company.website = "www.example.com"
@company.save
@company.website #=> "http://www.example.com"

Available now, free on Github

Update: Des and James were quick to point out that my initial release would incorrectly add "http://" to "https://" URLs. Quick patch!

Do You Realize - that you have the most beautiful face Do You Realize - we're floating in space - Do You Realize - that happiness makes you cry Do You Realize - that everyone you know someday will die

And instead of saying all of your goodbyes - let them know You realize that life goes fast It's hard to make the good things last You realize the sun doesn't go down It's just an illusion caused by the world spinning round

I met an interesting guy in San Francisco last week who shared some of his experiences trying to get a job in tech there. When he described the people in San Francisco and their attitude, he bowled me over with this line:

"People here don't expect you to know everything. There's no such thing as "stuff you should know" ... just "stuff you know" and "stuff you don't"

It's such an accepting attitude, and one of the wisest things I've heard in a while. I'm often blown away by how people haven't heard of this thing or that thing that I've known for a long time. Equally, I appreciate how much I can learn from others.

"In 2001, Jim Collins published a best-selling study called “Good to Great.” He found that the best C.E.O.’s were not the flamboyant visionaries. They were humble, self-effacing, diligent and resolute souls who found one thing they were really good at and did it over and over again."

Find one thing you're good at and do it over and over again. The one true path to success?

Pet Sounds with all the orchestration removed. Just the vocals. Shows just how good the songs were before Brian Wilson got into the producer's seat.

Long, interesting and useful piece chock full of tips to help developers make their work a bit more palatable to humans

There was never yet an uninteresting life. Such a thing is an impossibility. Inside of the dullest exterior there is a drama, a comedy, and a tragedy.

This is about five or six doors down from where I live. He's since been removed from service!

Maintaining best practices is hard, but it helps to look at it in the context of the smells you leave behind when you don't adhere to them.

I particularly like the format of putting out a tweet and bringing them together in a blog post.

Eric Meyer, Wilson Miner, Ryan Sims, Tim Van Damme, Andy Budd and Sam Brown, coming to Belfast in November. Andy McMillan is definitely one to watch.

While working with Rails ActiveRecord models recently, I've found that I'm never sure where to put things. Should validations go before relationships? Should class methods come before instance methods? I've started keeping a coding guideline for myself to keep things nice and consistent. It doesn't follow much of a rational order, but it's something, and I've gone with my gut and my gut is happy. Here's what I've come up with:

• includes
• validations
• called class methods
• relationships
• callbacks
• named scopes
• class method definitions
• public method definitions
• private method definitions
• callback method definitions

So, for example, here's how a Post class would look:

class Post < ActiveRecord::Base
  # includes
  include SpecialPostMethods
  
  # validations
  validates_presence_of :title
  validates_uniqueness_of :slug
  
  # called class methods
  acts_as_textiled :body
  
  # relationships
  belongs_to :site
  has_many :comments
  
  # callbacks
  after_create :save_slug
  after_save :ping_technorati
  
  # named scopes
  named_scope :most_popular, :order => 'votes DESC'
  
  # class method definitions
  def self.post_types
    ['post', 'page']
  end
  
  # public method definitions
  def permalink
    ...
  end
  
private
  # private method definitions
  def flush_cache_entry
    ...
  end
  
  # callback method definitions
  def ping_technorati
    ...
  end
  
end

Your mileage may vary with this, but I've found that it's really helped me not have to think about where I'm putting stuff. Everything now has a place, so I know I can consistently put things where they should be, or tidy things up when I'm using old code.

I like catching up on Dave Winer's blog every so often. It's definitely a whole lot more than scripting news.

I like his thoughts on ideas in snowstorms ... the kind of moments I guess that James Webb Young promotes in "A technique for producing ideas" ... the snow storm (or whatever) jolts the subconcious mind to look at old ideas in a new light.

I also like the idea of Digg for ads ... I love being advertised to when a) it's a really exciting ad and/or b) I really want the product. I really hate it when a) The ad is awesome but it's some crummy product like fat-free yoghurt or b) it's some crappy thing and it's on the TV because the guy's cousin knew the station manager and a bit of Final Cut pro.

I also hate those crappy musical Halifax ads.

Terrifying to think that this is real life, that it's probably just a cross-section of what's out there.

Your whole world could be falling down around you and you'd have a hard time not living up to the title of this song.

I like how they don't mention anything about what the drawing is in the caption.

Hampton Hates Automated Testing from Hampton Catlin on Vimeo.

I don't necessarily agree with this, but I do believe that one should always have a good healthy balance in life! My stance is that testing code is one of many disciplines to help you reflect on the work that you've done. As well as the obvious benefit of helping you out when you break stuff later!

My favourite comment: "whoa, your hair! obviously i have nothing productive to say about automated testing. ps. nice shirt!"

One of the reasons I set up this tumble-loggy blog, rather than stick with a regular blog, was so that I could share little snippets of code every so often, related to the stuff I was working on.

That's why I was delighted when Jon Crawford (NewMonarch) on Twitter asked me this:

I need to grab a Twitter user’s followers on the fly. As you probably know, the friends list isn’t returned in alphabetical order. Instead it’s returned in the order of which you started following the user, 100 results as a time. I’d prefer that the results were returned in alphabetical order by screen_name.

I like this kind of request, because it's one I know the answers to!

Since the beginning, Twitter has provided friends / followers methods for getting a list of a Twitter user's friends or followers. These methods have been damned to hell though, because they only report back 100 users at a time. Worse, they send back all manner of extra data, such as the latest tweet and in depth profile information. This meant for a lot of wasteful traffic back and forth to the API, and crucially lots of requests, eating up your API limit.

This was a particular bone of contention for an app like Qwitter. For someone like Gary Vaynerchuk for example, with tens of thousands of followers, we'd have to make hundreds of requests to the api just to get a list of Twitter follower IDs. A fun programming exercise, no doubt, but seriously inefficient.

At the beginning of February, Twitter released two methods that mark a change in the game for Twitter API developers: their social graph methods

Essentially, these methods let you download an entire friends list or followers list in a single API call:

curl http://twitter.com/friends/ids.xml?user_id=1401881

It just returns a list of IDs, but it's massively more efficient than making lots and lots of calls to the API, particularly for Qwitter.

For Jon Crawford's problem, it marks the beginnings of a solution. Because Qwitter compares the differences in two lists of IDs, we don't rely on associating usernames with IDs.

Here's a script that returns an array of friends sorted in alphabetical order. I've used John Nunemaker's excellent Twitter gem.

The big problem with this script is that it's actually more inefficient than paging through 100 followers at a time, as it makes one API request per user. Perhaps for the first run of a user, something like this would be better:

Then keep a cache of usernames and associate them later. It all really depends on your needs.

This occassionally pops in to my head and makes me smile. I love the simplicity but also the harshness of the melody.

It took me 5 minutes to get an eighth of the way across. Fun though!

I've been using Screenflow for the last few days to do some screen casts for a client. It's pretty good. Not perfect, but neater than Snapz Pro X.

I developed a pretty good flow, which I'd like to share. One thing I can't emphasise enough is the need to write a script. I tried doing voiceover and actions at the same time and it just ended up a mess trying to type and talk convincingly at the same time. Here's the flow:

• Write a script based on the client's requirements. Guess at how long the action will be on screen to decide on how wordy each explanation should be.
• Do the screen capture video with the script on screen. I kept mine in a narrow window along the right side of my screen. I glance at the script while I record the actions, trying to hear myself saying the words in my head, to keep pace.
• Save the video and record the voiceover on a new track. In Screenflow, you can hit Apple-Shift-R to add a recording. You have to manually hit play on the controls to play back the 'cast.
• You might need to tweak the script if it doesn't quite match the video. Try and keep the pace smooth, but don't be afraid of a gap every now and again.
• Rinse and repeat

I can't emphasise enough how important it is to have a script. I'm constantly tweaking, tweaking, making sure the words are just right.

This flow would probably make a good screencast itself. I might do that some time. It would also make for a very neat presentation. *Adding to my list*

This last week has been very conference heavy, but it's also been an indicator to me that there's lots of stuff inside my head that people could probably make use of. I'd be really interested in speaking more about my experiences with:

• CouchDB - I've dabbled a good bit and released Stuffing
• Amazon Web Services (particularly EC2 + EBS, S3 and SQS) - Lots of experience building and scaling Exceptional
• Customer service - I've manned the feedback email for Exceptional since we launched

The list is really for my own reference, but if you'd like to hear my thoughts on these, get in touch!

I gave a talk last Wednesday at "API wars", a Web2Ireland event on APIs before the Facebook Developer Garage. It seemed to go down very well. I think the whole thing was filmed, so hopefully all the talks will be available online. It was my first talk in front of a sizeable audience and it went very well. My green-on-black Terminal screenshots didn't appear on the big screens, so with apologies to _Why, I left the stage to show the crowd how the Ruby Twitter gem works. A lot of fun.

I've made the slides available as a PDF.

Twitter's social graph methods, launched last month, are the secret sauce behind Qwitter. Up until yesterday, when I implemented these methods in the app, I had been mocking them by using round robin to loop over the many thousands of Qwitter users, paginating through hoards of data just to extract the user IDs of followers.

Now I can get all the user IDs of someone's followers in just a single API call.

This is big news not only for Qwitter, but for any app that is doing things with followers lists. No more are we restricted to the 100 per page limit that was imposed before ( plus the unecessary bloat of getting latest status, screen name etc.

The good news is that I can now say that Qwitter should be able to maintain a decent bit of reliability, at least up until around 250k users. We're not quite there yet.

Two writeups in a week, awesome. Exceptional was featured in Smashing Magazine's 10 Useful tips for Rails Developers ... we got a really nice big screen plastered on the "Track application exceptions" section.

Also, to my delight, Stuffing is featured on Rails Inside. Proud to see my little experiment get attention. I think that CouchDB really is the next big thing.

As it turns out, my maths suck. I was informed yesterday that a mile is actually 64 lengths, not the 32 that I achieved... I was basing my figures on the pool being 50m in length, not 25m.

Still, I was actually happy enough to learn that, as the point of my post was less that I swam a mile and more that a definite goal is more easily achieved. I now have a new definite goal: 64 lengths. A mile!

I started swimming a couple weeks ago as a way of relaxing / keeping fit in the morning. I've been going in about a half hour before I start working, so I only fit about 10 lengths in. Today I got in a bit earlier and when I got to 15, I realised that I'd swum about 750m. I realised that hey ... I could get to a thousand, and if I really wanted to, I could probably get up to 1.6k - the elusive mile! Well, it's surprising how easy those next 17 lengths came to me once I had that goal. A mile! There was something exciting about that last length, legs flailing, arms all over that place. Exciting, rewarding. A mile!

Update: Actually, it was only a half-mile. Dang!

A client recommended this after a long day's work. Louis CK on counting your blessings ... "Maybe we need some time where we're walking around with a donkey with pots clanging on the sides"

Apparently one of the songs that I've been working on with some mates is very similar to one of these. Dang!

Extraordinarily responsive breakdown of your own personal Google usage. Eerie, but useful!

The UK Companies House company search shuts down after midnight. Doesn't this kind of miss the point of the internet?

Some good insight from one of the smartest guys on the web

So getting the Yahoo YUI uploader to work with Rails is a bit like voodoo. Cameron has published a concrete example using jQuery as well as YUI that works right out of the box.

A description of the courtroom proceedings of the legal case against The Pirate Bay. A riveting, exciting read, an irony-fuelled good vs. evil battle Paul Campbell tag:www.pabcas.com,2009:20 2009-02-19T15:21:21Z 2009-02-19T15:21:21Z

The YUI uploader is an open source extraction used in the Flickr web-based uploader. Cool stuff, and in theory more reliable than SWFUpload if it's in production use on Flickr.

In my screencast below, I used an 'fd' tab trigger in Textmate to generate a div containing a field and a label. This isn't part of the Rails Textmate bundle. Here's the code to generate a label and field inside a div:

<div>
  ${RAILS_TEMPLATE_START_RUBY_EXPR}f.label :${1:attribute}${2:, "${3:${1/[[:alpha:]]+|(_)/(?1: :\u$0)/g}}"}${RAILS_TEMPLATE_END_RUBY_EXPR}
  ${RAILS_TEMPLATE_START_RUBY_EXPR}f.text_field :${1:attribute}${RAILS_TEMPLATE_END_RUBY_EXPR}
</div>

Much as our Exceptional competition is "healthy," Thoughtbot are a smart bunch. Paperclip is a top drawer attachments plugin and this post by Chad Pytel is an interesting read on how to prevent pages being cached in Rails controllers. Normally caching is a useful tool for improving the response of your webapps, but in many cases you want the data to be fresh on every request. Take home point: if you want your page to be 'cache-resistant' in Safari and IE, stick an empty iframe in it.

The Dublin Twestival was on last night. Lots of people, lots of fun. Cool to see a LOT of faces that I've not met before alongside a healthy dose of regulars. Bonus appearance from and photos of Twink, who showed up with an entourage from BScene model agency. Crazy. Hope you enjoy my photos. I got a good one of Twink and another good one of Jason Byrne.

Niall Harbison tweeted last Saturday that he had an idea for an app that he wanted done quickly. We got on board straight away. I hacked a prototype together, Eoghan did the design and Des helped with the all the projecty bits. Twecipe was born yesterday. I'm quite proud of how much we got done in just a few days, while keeping plenty of time for client work.

My Apple-Tab key combo to switch apps wasn't working. Des gave me a neat little one liner to fix it:

killall Dock

This stops the Dock, which gets automatically restarted by OS X, and very quickly Apple-Tab works again. Sweet

Doctor Millar is playing Dublin tonight in Bewley's Cafe Theatre. I recommend the show. He's also playing next Wednesday, which is when I plan to go see him.

Setting desktop backgrounds to mimic what's actually behind them. Very smart. Very creative. I really like the transparent one

"You’ve got to be able to write a single line of code and see a result." _why nails it.

I went along for drinks with all the lads who had attended the Innovate Europe event with EI last week. As usual, I had my camera so I snapped a bunch of headshots. I think there are a few high-profile guys in there.

Stuffing is a Rails plugin that lets you add a CouchDB data store to an existing ActiveRecord model.

class Post < ActiveRecord::Base stuffing end

The Post model above is just an ordinary ActiveRecord model. It has a MySQL table called "posts" behind it. The fields in the posts table get mapped to methods in instances of Post. But it also has the meta-attribute: stuffing. You can assign a hash of arbitrary keys and values to the stuffing method and it will be persisted automatically to CouchDB.

It works like this:

@post = Post.new({:title => "Cake", :post_type => "recipe", :stuffing => {:ingredients => ['flour','sugar','eggs'], :description => 'mix them all up'}) @post.save @post.stuffing => {:ingredients => ['flour','sugar','eggs'], :description => 'mix them all up'}

When you save this, with @post.save, the :stuffing gets saved to CouchDB. You can retrieve the attributes by accessing the stuffing hash: @post.stuffing['ingredients'] or you can call them by prefixing stuffing_ : @post.stuffing_ingredients. The data gets updated when you update it. It's just like having a big mega-hash in the sky on top of regular old ActiveRecord.

What's the point? Why not just use a CouchDB wrapper like ActiveCouch, CouchRest::Model etc.? Well, CouchDB has a lot of features. It's got javascript views with map-reduce, crash-only design, schema-less documents, bi-directional replication. Lots of really cool stuff that one day we'll all have in our own living rooms. But right now, today, it's only really the schema-less design that appeals to me. I mean, I love the other stuff, but when I'm quickly prototyping an app (as I often am in Rails), I love the idea of just being able to add another field to a form and bam! I have a new attribute. But then I want to be able to quickly hook on all the tried and true ActiveRecord plugins that I'm used to. Hell, I want to be able to call Post.first, Post.last and Post.all.

Stuffing helps to gently add a CouchDB layer to your Rails app without completely removing you from ActiveRecord. Think of it like swimming in CouchDB with arm-bands. Or like a Couch, but without the covers, trimmings or fancy coasters. Just the stuffing.

The plugin is yours, available to enjoy on Github: http://github.com/paulca/stuffing/ where there's a full documentation and some more examples. Feel free to contact me if you have any questions, or fork the project and patch back if you think I screwed something up, or if something can be improved.

I've had such a good amount of time with CouchDB over the last few months. I first read about CouchDB when I was back in college on Tobias Luetke's blog. It sounded awesome, but that was about that. At the time, it was quite complicated to get up and running, at least too complicated for me.

Then last year I met Jan Lehnardt and the game changed a little for me. I knew someone connected directly with the project. It became exciting for me. Jan got me up and running with a masterclass in CouchDB at RailsConf Europe last year. My appetite was squarely whetted.

My first foray into CouchDB was a little experiment called "Couchy". Couchy uses a TemplateMap class to parse fields out of HTML and create a schema out of them. It was a fun little project and got me up and running with the basic concepts.

It was a while before I got to try anything else, but in the meantime, Chris Anderson had published CouchRest::Model, which was very interesting, because it attempted to create more ActiveRecord-like models out of CouchDB, including dynamic views. It was full of smart stuff.

I got my hands dirty with CouchRest::Model building the first iteration of this little tumble log. I wanted a dynamic data store so that I could post any kind of content - a post, a quote, a link whatever, but I wanted to add to these easily in the future. Not like create a new database field or fill out some crazy schematic. Like just add a new form and I'd have a new post type.

I got quite far with CouchRest::Model, but then a cascade of issues hit me. What about pagination? What about attachments? What about search. All of these things have been solved really well with will_paginate, Paperclip, ThinkingSphinx. There had to be another way.

Today, in about 20 minutes, I was able to take the cool schema-lessness of this little tumble-log and hook it into a couple of ActiveRecord models that I'll be able to use with the above plugins and ActiveRecord finders. I used "Stuffing" a little plugin I wrote to do just that. Stuffing is the subject of my next post.

This is my old blog. I used Mephisto, which I quite liked, but I found that it ... wasn't just for me. So like any good hacker, I wrote my own blogging engine. And away I go.