Logan Koester

errship

2011-08-30T00:00:00-07:00

errship

30 Aug 2011

The static error pages Rails comes with are nice for getting started - you can’t break them, no matter what. But without your layout and navigation wrapped around them, they create a frustrating trap for your users.

The obvious solution is to render your layout into the static file, but what happens when you make a change?

Worse, what if you run a network of many Rails applications? Should they share one error page style? Should they all have their own?

You could hire your nephew to keep them all up to date… or you can use Errship.

Errship is a Rails 3.1 engine for rendering error pages inside your layout. It supports i18n, custom exceptions, and Airbrake (Hoptoad) error tracking.

You can also use the flashback method to set an error message and redirect :back safely - if a RedirectBackError is raised, the user is dropped off at the nearest error page and given the flash message anyway.

Check it out on Github at https://github.com/agoragames/errship

Soonatra - 'Coming Soon' pages on Sinatra

2011-07-20T00:00:00-07:00

Soonatra - ‘Coming Soon’ pages on Sinatra

20 Jul 2011

I was recently tasked with creating a “coming soon” page for a new project at work. The requirements were the usual:

Some description of the project features
A form to signup for an email list / invites
Display a few posts from an RSS feed
Show some screenshots of what we’re building to collect early feedback

We’ve also been increasing our focus on A/B testing (aka “split testing”), so I wanted a way to try out different headlines and see which angle users find most interesting.

This all sounds well and good, but it is very frustrating to take time away from the beginning of an exciting new project to invest in a page that will only be online for a few short weeks.

I decided I don’t ever want to do it again, so I created Soonatra.

Soonatra is a simple Sinatra based framework for creating these pages quickly.

Soonatra reduces the steps involved to:

Create a mailing list (we’re using Mailchimp)
Choose some colors/graphics that fit well with your brand
Write the page copy and set an RSS feed url.
Deploy to a free Heroku account and park your domain.

It is easy to extend and manage multiple themes thanks to Compass, and does not require a database, instead using Redis for RSS feed consumption and tracking A/B test results.

You can fork the git repo and have your site up and running in minutes.

See README.textile for all the juicy details.

FeedzirraRedis

2011-07-20T00:00:00-07:00

FeedzirraRedis

20 Jul 2011

If you’ve ever wanted to include some data from an RSS/Atom feed on a page from Ruby, you’ve probably run into this problem:

It’s completely unreasonable to hammer the feed provider with a request every time the page is rendered, but it’s no more reasonable to use a big relational database like MySQL just to cache some stupid tweets or blog posts, especially if your application wouldn’t otherwise need one.

But apparently this layer of persistance has been deemed out-of-scope by the creators of popular RSS consumer libraries such as Feedzirra.

So I wrote a little gem called feedzirra-redis to take care of this as transparently as possible. You can use it just like you would Feedzirra normally, but your feeds and entries do not disappear at the end of the script, so you can do the dirty work from a Rakefile via cron instead of in the web request/response cycle while your users impatiently twiddle their thumbs.

Installation

$ gem install feedzirra-redis

See the README and test suite for example usage.

Enjoy!

A Dynamic DNS client in Ruby

2011-03-17T00:00:00-07:00

A Dynamic DNS client in Ruby

17 Mar 2011

Back in 2008 I wrote a Ruby gem for updating your IP address at afraid.org, the free Dynamic DNS service. For whatever reason I moved onto other things, and never published the gem. It’s pretty basic but serves my needs, and may serve yours, so I’ve fixed it up and pushed version 0.1.2 today.

Installation

$ gem install updateafraid

Usage

$ updateafraid --help
Help for commands:
  -user       (Required, takes 1 argument)
                  Your Afraid.org username
  -pass       (Required, takes 1 argument)
                  Your Afraid.org password
  -domain     (Optional, takes 1 argument)
                  Update IP address for one domain: -domain <name>
  -all        (Optional, takes 0 arguments)
                  Update IP address for all domains in your account
  -h          (Optional, takes 0 arguments)
                  Help

The code is hosted at github.com/logankoester/updateafraid under an MIT License.

Switching to Jekyll

2010-12-17T00:00:00-08:00

Switching to Jekyll

17 Dec 2010

Wordpress has served me pretty well for over 5 years now, but it’s time for a change.

Over those 5 years, I’ve been writing less and less. I’m not entirely sure of the reason, but I think it just comes down to friction. Editing text in a browser sucks, I had to log in, ran into layout problems a lot with simple things like code highlighting and inserting an image…

Anyway, I’ve had my eye on Jekyll since it was announced, and I finally decided to try it out. I haven’t even completed my first post yet, and I’m already glad that I did.

I can post straight from Vim.
My blog is version controlled with Git in plaintext files, not tucked away in a gigantic database
It’s fast. Seriously, static html vs php feels noticably faster even on a local system.
I can extend it with simple Ruby… writing a Wordpress plugin is a pain in the ass (like most things PHP).

If I can get Haml working as well, I’ll be the happiest blogger on earth.

One potential downside for people who just want to get a site up quickly without a big design effort is that (as far as I know) there isn’t a central repository of free themes available. I borrowed this CSS from Dan Hixon’s überduper. I couldn’t find a license, but it is in a public GitHub repository so I hope he doesn’t mind sharing.

I haven’t migrated all my WordPress posts over yet, but I’ll work on getting the most useful or popular ones back online when I have some time.

In conclusion, if you haven’t tried Jekyll yet or want something a little lighter than your current blogging engine, definitely give it a shot!

Bundler + Watchr

2010-08-20T00:00:00-07:00

Bundler + Watchr

20 Aug 2010

If you’re using test-driven development (and it’s definitely a cliche by now, but if you’re not – you should be), I highly recommend Watchr to run your test suite. The concept is simple: whenever you save a file, it runs the related tests for you. It’s basically a modernized autotest, and I couldn’t live without it. It’s totally the best workflow ever.

Lately I’ve been switching my Ruby projects to the new Bundler system for managing gem dependencies. With Bundler, whenever you add a gem into your Gemfile, you have to then run “bundle install” to grab it. If you’re already using Watchr to autorun your tests, it is trivial to automate this.

Just add this line to your test/test.watchr (or whatever you call it).

  watch('Gemfile') { puts `bundle install` }

Add a gem to your Gemfile, hit save… gem installed!

Does it take you a while to get started in the morning?

2010-05-18T00:00:00-07:00

Does it take you a while to get started in the morning?

18 May 2010

It does for me. When I actually am ready to sit down and do some Rails hacking, I still have to fire up a couple irb consoles, open my editor, make sure Redis is running, start a resque worker, autotest, log tails, etc etc etc… I’d really rather get right to it, wouldn’t you?

$ rake day:begin

Ahhh, that’s much better!


namespace :day do
  task :begin => [:gvim, :console, :logs, :watchr, :server, :resque]

  task :console do
    puts "Opening IRB console..."
    `gnome-terminal --window-with-profile=railsconsole -x script/console`
  end

  task :logs do
    puts "Opening log files..."
    `gnome-terminal --window-with-profile=rails -t "Rails Logs" -x tail -f log/*`
  end

  task :watchr do
    puts "Starting test watchr..."
    `gnome-terminal --window-with-profile=rails -t "Test Watchr" -x rake watchr:test`
  end

  task :gvim do
    puts "Starting gvim..."
    sh 'gvim'
  end

  task :server do
    puts "Starting application server..."
    `gnome-terminal --window-with-profile=rails -t "Application Server" -x script/server`
  end

  task :resque do
    puts "Starting resque web... (http://localhost:5678)"
    `resque-web 2> /dev/null`
    puts "Starting resque worker..."
    `gnome-terminal --window-with-profile=rails -t "Resque Worker" -x rake day:quick_resque_worker`
  end

  task :quick_resque_worker do
    sh "QUEUE=* rake resque:work"
  end
end

namespace :watchr do
  task :test do
    sh "watchr test/test.watchr"
  end
end

Into my Rakefile it goes! And if you like that, be sure to check out git-pivotal – grab the next thing to do and give it its own branch with just one more command. Anyone feeling clever enough to implement a rake day:end as well?

Planning

2010-02-05T00:00:00-08:00

Planning

05 Feb 2010

Sometimes I wonder why I bother…

Bayesian Classification on Rails

2010-01-26T00:00:00-08:00

Bayesian Classification on Rails

26 Jan 2010

A project I’ve been working on watches Twitter for some search keywords, with the goal of finding new customers, jobs, items for sale, etc. For example, a computer repair shop might want to watch for the keywords “laptop” and “broken”, and then reply to tweets where they think they can help.

But as anyone who uses Twitter can attest, even with some very specific search terms, language filtering and geocoding, there is going to be a lot of white noise. I decided to take this one step further.

Bayesian classification (your garden-variety spam filter) in ruby is quite easy, thanks to ruby-stemmer and the excellent classifier gem. The canonical example:

require 'classifier'
b = Classifier::Bayes.new :categories => ['Interesting', 'Uninteresting']
b.train_interesting "here are some good words. I hope you love them"
b.train_uninteresting "here are some bad words, I hate you"
b.classify "I hate bad words and you" # returns 'Uninteresting'

Of course, if you’re implementing this in a Rails application, chances are you want the classifier to learn from real data over time. In my case, I want it to learn that a tweet is uninteresting when I delete it, and I want it to learn that a tweet is interesting when I visit the Tweet#show action.

It seems the usual method is to marshal the classifier object with madeleine, which creates a new snapshot file each time you train it. This is both easy and fast, but we’re going to end up with thousands or millions of snapshot files in no time flat. Additionally, all bets are off if we have a few users who are really into cheap viagra. We need to give each User his own classifier and let him train it over time.

First, let’s set up our environment. Grab the latest ruby-stemmer and classifier gems from Github, and build them from source. I recommend this because the gem versions I got on my first try were way out of date and quite broken, and because you’ll need a classifier fork with my remove_stemmer method to marshal your classifiers using ActiveRecord.

$ git clone git://github.com/aurelian/ruby-stemmer.git
$ cd ruby-stemmer
$ rake compile
$ sudo rake install
$ cd ..

$ git clone git://github.com/logankoester/classifier.git
$ cd classifier
$ sudo rake install

$ sudo gem install twitter

Generate a fresh rails app if you want to follow along.

$ rails classifier_rails_example
$ script/generate resource user id:integer classifier:text
$ script/generate resource keyword id:integer user_id:integer text:string
$ script/generate resource tweet id:integer keyword_id:integer user_id:integer \
  text:string read:boolean interesting:boolean
$ script/generate migration ChangeClassifierDefaults

Alternatively, you can clone the code from this tutorial with:

$ git clone git@github.com:logankoester/classifier_rails_example.git

Now edit the migration you just created to look like this:

class ChangeClassifierDefaults < ActiveRecord::Migration
  def self.up
    change_column :tweets, :interesting, :boolean, :default => false
    change_column :tweets, :read, :boolean, :default => false
    change_column :keywords, :text, :string, :default => ""
  end
def self.down
change_column :keywords, :text
change_column :tweets, :read
change_column :tweets, :interesting
end
end

…and run it

$ rake db:migrate

Open your config/environment.rb file, and add the following gems to the Initializer block.

config.gem 'ruby-stemmer', :lib => 'lingua/stemmer'
config.gem 'luisparravicini-classifier', :lib => 'classifier'
config.gem 'twitter'

Now we can use ActiveRecord’s built-in YAML serialization to store the classifier.

class User < ActiveRecord::Base
  has_many :tweets
  has_many :keywords

  serialize     :classifier, Classifier::Bayes
  before_create :initialize_classifier
  before_update :remove_stemmer

private

  def initialize_classifier
    self.classifier = Classifier::Bayes.new(
      :categories => ['Interesting', 'Uninteresting']
    )
    remove_stemmer
  end

  def remove_stemmer
    self.classifier.remove_stemmer
  end
end

The remove_stemmer method requires a little explanation. When a Classifier is initialized, it also creates a Stemmer object to use, which ordinarily gets marshalled along with its Classifier. But when demarshalled later, the Stemmer object (which is really just a C extension) will get caught with its shorts down, and either throw an error like “Stemmer is not initialized”, or in older versions, simply segfault your rails environment!

The solution is simple; my fork implements a remove_stemmer method on Classifier::Base, which will force the stemmer to be reinitialized the next time it is needed. Call this method before you marshal your classifier, and your troubles will melt away.

Moving on to the Tweet model, we want to classify each tweet when it is created.

class Tweet < ActiveRecord::Base
  belongs_to :user
  belongs_to :keyword

  before_save :classify
  
  def classify
    text = self.text.gsub /#{self.keyword.text}/, ''
    if self.user.classifier.classify(text) == 'Interesting'
      self.interesting = true
    end
  end
end

Of course, we don’t want to throw off the results by including a word which is going to occur in every tweet, so we remove the search term from the text prior to classification.

Add a little method to your Keyword model to grab new tweets from the Twitter Search API

class Keyword < ActiveRecord::Base
  belongs_to :user
  has_many   :tweets, :dependent => :destroy

  after_save :search

  def search
    search = Twitter::Search.new(self.text).fetch
    search.results.each do |r|
      t = Tweet.create(
        :keyword => self,
        :user_id => self.user,
        :text => r.text
      )
      t.save
    end
  end
end

Almost done! Now we need to train our sweet new classifier. I’ve opted to do this entirely from the controller, so that messing around in the console won’t inadvertently have an impact on the machine’s learning. We also want to mark the tweet in question as already read, so that the lesson is only learned once.

class TweetsController < ApplicationController

  def show
    @tweet = Tweet.find(params[:id])
    unless @tweet.read?
      current_user.classifier.train_interesting(
        @tweet.text.gsub(/#{@tweet.keyword.text}/, '')
      )
      current_user.save
      @tweet.read = true
      @tweet.save
    end
  end


  def destroy
    if @tweet = Tweet.find(params[:id])
      if @tweet.destroy
        current_user.classifier.train_uninteresting(
          @tweet.text.gsub(/#{@tweet.keyword.text}/, '')
        )
        current_user.save
      end
    end
  end

end

And there you have it… a simple machine learning solution for extracting awesome tweets. Let’s try it out!

Fire up a script/console session.

Loading development environment (Rails 2.3.5)
>> u = User.create
=> #<User id: 1, classifier: #<Classifier::Bayes:0xb64f2354 
  @categories={:Uninteresting=>{}, :Interesting=>{}}, total_words0, 
  stemmernil, options{:encoding=>"UTF_8", 
  :categories=>["Interesting", "Uninteresting"], 
  :language=>"en"}, created_at: "2010-01-26 22:17:19", 
  updated_at: "2010-01-26 22:17:19"

As you can see, our new user has a Bayesian Classifier waiting around to learn what kind of tweets he likes.


>> u.keywords.create(:text => "robots")
=> #<Keyword id: 1, user_id: 1, text: "robots", created_at: "2010-01-26 22:20:55", 
  updated_at: "2010-01-26 22:20:55">
>> Tweet.all.size
=> 15

You can use the following oneliners from script/console to play around with the training:

Keyword.all.each {|k| k.search} # Rerun all searches to grab and classify more results

# Any tweet with the word "cyborgs" is interesting
Tweet.all.each { |t| 
  u.classifier.train_interesting(t.text) if t.text.downcase.include? "cyborgs"
}

# Any tweet with the word "discount" is uninteresting
Tweet.all.each { |t| 
  u.classifier.train_uninteresting(t.text) if t.text.downcase.include? "discount"
} 

# Print the interesting tweets and count them
Tweet.find_all_by_interesting(true).each do |t| pp t.text }.size 

# Rerun the classification on every tweet
Tweet.all.each {|t| t.classify }

Of course, this technique can be applied to sorting pretty much any kind of text. Interesting/uninteresting tweets are just one example from my life. Start hacking!

Fun with ion3

2009-10-07T00:00:00-07:00

Fun with ion3

07 Oct 2009

Ion™ is a tiling tabbed window manager designed with keyboard users in mind.

In recent years I’ve been a GNOME / Compiz guy, but while I’ve enjoyed it’s tight integration with Ubuntu and flashy effects, I’ve always missed the simplicity of so-called minimalist window managers, mainly fvwm. These days, however, practically everything I do happens inside a Firefox, gvim, or gnome-terminal.

I want keyboard-driven. I want scriptable. And I don’t want windows hiding behind other windows. Ever.

Enter ion3. I’ve only been using it for the last 24 hours, and even though I haven’t memorized all of the keymaps, or learned how to code in Lua (yet!), I already love it. So far the only problem I’ve not been able to overcome is a bug in the latest Adobe Flash that breaks fullscreen video. This isn’t specific to ion3 – it’s a problem with any focus-follows-mouse system. I hear there is a workound, but it didn’t seem to work for me. I consider it a microscopic trade-off for such an efficient window manager. Many of my previously sluggish applications now run incredibly fast, and with a couple days of practice I’ll be working faster too.

Installation

$ sudo apt-get install ion3 ion3-dev ion3-scripts ion3-doc

Now just log out, choose ion3 and start a new session. The first time you log in you’ll be greeted with the man page, which I highly suggest reading. If you try not to “cheat” by using the mouse, you’ll pick up almost everything in a couple of hours, and from there you’ll find yourself navigating faster and faster until you don’t have to think about it at all. Just like vim.
Ion is both simple and well-documented, so it would be pointless for me to write introductory tutorial. Instead, here are a couple tricks I’ve discovered.

Modifying your configuration

One of the first things you’re going to want to do when you’re done messing around is change a few settings. For the most part, this is done in a file called cfg_ion.lua. Copy the system-wide file (I found mine at /etc/X11/ion3/cfg_ion.lua) to ~/.ion3/cfg_ion.lua and open it with a text editor.


$ mkdir ~/.ion3
$ cp `locate cfg_ion.lua | head -1` ~/.ion3/cfg_ion.lua
$ gvim ~/ion3/cfg_ion.lua

You’ll need to restart Ion for your changes to take effect. Don’t worry, all your applications will stay open; only the window manager needs to be restarted. Hit F12 and type session/restart.

I messed this file up a few times experimenting, and I’ll probably mess it up a few more. If you screw up this file like I did, your F12 shortcut can disappear, and you’ll need another way to restart Ion after you’ve fixed it. Keep a terminal open whenever you’re editing, because you may not be able to launch one. The trick to restart Ion from the console is simple:


$ ps -e | grep ion3 # 21108 ?        00:00:16 ion3
$ kill -USR1 21108

Remapping Mod1

The Mod1 key is used to initiate most interactions with Ion. On most systems, this is Alt. This is usually a very bad choice, because a lot of other applications need the Alt key for other things. I tried the Flying Window key, but it turns out it’s in a very uncomfortable place on the keyboard. The number keys are used a lot. Try reaching Win+6, and you’ll see what I mean. CapsLock has been working great for me, and as an added bonus, makes it much more work to shout on IRC.

Check your keymaps with xmodmap -pm. On my system, Mod3 was unused, so I remapped CapsLock to that.

Edit (or create) ~/.Xmodmaprc and insert these lines at the bottom…


remove Lock = Caps_Lock
add Mod3 = Caps_Lock

Then run it…

/usr/bin/X11/xmodmap ~/.Xmodmaprc

Also add this line to ~/.Xsession so it is run automatically whenever you start X.

If your xmodmap -pm now reads…

mod3        Caps_Lock (0x42)

then you’re in luck! Now you just need to edit the META variable near the top of your cfg_ion.lua to reflect the change

META="Mod3+"

and restart.

All done! I hope you enjoy learning and using Ion3 as much as I have. I don’t think I’ll be switching again any time soon.

Human Readable Text Compression

2009-06-13T00:00:00-07:00

Human Readable Text Compression

13 Jun 2009

As a Web Service

TweetShrink, a web service from TRNSFR, uses a database of common instant / text messaging abbreviations to reduce the number of characters in a tweet. It’s essentially a human-readable compression algorithm. For example, “Some text to shrink” becomes “sum text 2 shrnk” when passed through their API.

But it doesn’t enforce Twitter’s 140 character limit, which means it can be used beyond Twitter for whatever you like. Back in March I released the tweetshrink gem for Ruby, and today I’ve updated it to 0.2 which includes a command line interface.

From the command line

First, make sure you have Ruby and Rubygems installed. On Debian-based operating systems (such as Ubuntu), this goes a little something like

$ sudo apt-get install ruby rubygems

Now install the gem from it’s GitHub repository:


$ sudo gem sources -a http://gems.github.com # (only need to do this once)
$ sudo gem install logankoester-tweetshrink

You can use it from the command line like this:


$ echo "Some text to shrink" | tweetshrink
# Or with a file...
$ tweetshrink ./file_to_shrink.txt

From vim

Or, you can integrate it with vim for ultimate text shrinking convenience. Just add the following to your .vimrc:


""""""""""""""""""""""""""""""""""
" Tweetshrink text filter (:tws) "
""""""""""""""""""""""""""""""""""
autocmd BufEnter * vmap ,tws !tweetshrink<CR>
autocmd BufEnter * nmap ,tws !!tweetshrink<CR>

Now you can shrink a single line by hitting ,tws in Normal mode, or shrink a whole a visual block.

Of course, this is just as easy to integrate with your favorite text editor; I just happen to use vim.

On the Web

When I integrated this feature with my blog & tweet scheduler PingLater.fm, I realized TweetShrink didn’t have a favicon. I needed an icon to use for the button, so I created these – feel free to use them for whatever.
[gallery link=“file” columns=“4”]

PingLater.fm

2009-06-07T00:00:00-07:00

PingLater.fm

07 Jun 2009

I’ve spent the last couple of days working hard on a new app for managing your web presence.

There is a service called Ping.fm for broadcasting updates to your blogs, Twitter, Facebook, and other social networks all at once, from one place.

This can save you a lot of time if you’re trying to manage a brand or keep up with different groups of friends, and it makes it easier to prevent your presence on these sites from becoming stale.

The application I’m calling PingLater.fm takes it one step further. Now you can set up pings to be sent at a specified time in the future. You could schedule a product highlight for each day of the month, release new blog posts while you’re off on vacation, or whatever else you want to use a service like this for.

It’s free for now while I gather feedback and optimize the code, but free users will eventually be limited to 3 pings scheduled at a time.

I have a number of premium features in mind (RSS posting, image/video, iPhone…) to make it a really indispensable tool for pro bloggers and internet marketing people.

But we’ll get to that. For now, I just want to hear from you. Let me know what I can do to make this useful for you!

Click here to try it out!

Deploying Sinatra to a sub-URI using Passenger

2009-04-08T00:00:00-07:00

Deploying Sinatra to a sub-URI using Passenger

08 Apr 2009

It’s not hard, but it turns out there’s a trick to it. I’ve run into this problem twice now, so I figure it should be documented. This is the solution if your “/” route is resulting in “Not Found” or an Apache directory listing.

You can read more about the problem at Ardekantur’s “Phusion, Rack, Sinatra, and sub-domains”, but here’s my quick solution:

1. Disable mod_autoindex if it is enabled.
2. Make sure your RackBaseURI does not have a trailing slash.
3. Add this before_filter to your Sinatra app:

before do
  request.env['PATH_INFO'] = '/' if request.env['PATH_INFO'].empty?
end

I suppose an alternative solution would be feasible using Rack middleware, but this is what I’m using. Thanks to Ryan Funduk for helping me figure this stuff out.

Setting up rTorrent with Firefox

2009-03-14T00:00:00-07:00

Setting up rTorrent with Firefox

14 Mar 2009

Being the closest thing we have to a native uTorrent in Linux, I really like Deluge. But, at least for me, it uses a seemingly impossible amount system resources. Since a Bittorrent client is the kind of thing I want to leave running in the background, I needed a lighter alternative.

I don’t see any real need for a graphical interface when ultimately all it’s doing is moving bits around on a network, so I went with rTorrent. One of the benefits of using command-line software is that you can use SSH and screen to control it over the network… we don’t need no fancypants AJAX interface for this!

Part 1 – rTorrent

If you’re using Ubuntu, you can get rTorrent from the repositories, like so…

sudo apt-get install rtorrent

Now that you’ve got the software, you’re going to need to configure it. rTorrent looks for a configuration file called .rtorrent.rc in your home directory. Don’t panic. Just save the sample as ~/.rtorrent.rc and open it up in your favorite text editor.

You don’t need to worry about most of the stuff in this file, but you can if you want to. Here’s how I have it set up:


# Maximum and minimum number of peers to connect to per torrent.
# I like to limit this because I'm often connected through cheap
# wireless routers that have trouble with lots of connections.
min_peers = 40
max_peers = 450

# Same as above but for seeding completed torrents (-1 = same as downloading)
#min_peers_seed = 10
max_peers_seed = 50

# Maximum number of simultanious uploads per torrent.
max_uploads = 30

# Where do you want your downloads to go?
directory = ~/downloads

# You can put this anywhere you like, but I put it here.
# Remember that you'll have to create this directory
session = ~/.rtorrent/session

# Watch a directory for new torrents, and stop those that have been
# deleted.
# This will be important when we're setting up Firefox.
schedule = watch_directory,5,5,load_start=~/downloads/torrents/*.torrent
schedule = untied_directory,5,5,stop_untied=

# Port range to use for listening.
# Remember if you're connected through a NAT router, you'll
# need to forward these ports.
port_range = 50471-50479

# Enable peer exchange (for torrents not marked private)
peer_exchange = yes

Part 2 – Save Link In Folder

Okay, so you’ve got rTorrent all set up now, and configured to watch for new .torrent files in a directory (mine is ~/downloads/torrents/.torrent). Now let’s configure Firefox. There’s an extension by Achim Seufert called Save Link In Folder. You’ll want to install this.

After your browser restarts, go to Tools > Add-ons > Save Link In Folder > Preferences and add a new folder, like this…

Remember – the download directory must be the one you told rTorrent to watch!

Now when you click a torrent link, just save it instead of opening it with Deluge. If rTorrent is running it will notice the new torrent, and get to work! You can even queue up torrents while rTorrent is off, for downloading later.

I’m definitely an rTorrent noob, having just set this up tonight, but so far I like it a lot, and no longer have the performance issues I had using Deluge. This configuration would also be ideal for setting up a seedbox / media center machine, if you set up all your Firefoxes to save torrent files to a network mount on the server.

TweetShrink gem for Ruby

2009-03-06T00:00:00-08:00

TweetShrink gem for Ruby

06 Mar 2009

TweetShrink’s API is so simple that this gem barely adds anything on top of HTTParty, but here it is.

require 'rubygems'
require 'tweetshrink'

t = TweetShrink.shrink "One wonders why"
# t['difference'] => 4
# t['text'] => "1 wonders y"
# t['original_text'] => "One wonders why"

You can get it from my github account, here, or via rubygems like

$ sudo gem install logankoester-tweetshrink

Enjoy.

Installing Linux Mint 6 on your Asus EeePC 901

2009-01-08T00:00:00-08:00

Installing Linux Mint 6 on your Asus EeePC 901

08 Jan 2009

I was a fan of ubuntu-eee (now known as EasyPeasy) for a long time, but after upgrading to EasyPeasy 1.0 on my 20gb EEE 901 ($379.99) tonight, I’ve decided it’s time to move on, and I’m happy I chose Linux Mint. Here’s what I’ve done so far to get it running great:

Install Linux Mint

Since the EeePC has no optical media drive, you will need a USB flash drive to install Mint. Download the Linux Mint .iso file and use UNetbootin to burn it to your USB disk, then plug it into your Eee.

Turn on the machine and hit F2 to enter the BIOS setup. Set the boot priority to try the USB disk first. You may also want to make sure the webcam/bluetooth is turned on, while you’re here. Save your changes and reboot, and Mint will guide you through the rest of the installation.

When it asks you how you want to partition your disk, choose Guided – use entire disk and let it use the larger of the two SSDs.

Install the EeePC kernel

As usual with Linux installations, most of your hardware will work from the get-go, but not everything. The first thing you’ll want to do is get the wireless card working. Plug in an ethernet cable, and then follow these instructions. I recommend the lean kernel, and uninstalling the generic one since it will just be wasting precious disk space.

Enable Desktop Effects

Mint makes this easy for you by taking care of installing the correct drivers for your video card. All you should need to do is turn Compiz on in Preferences > Appearance > Desktop Effects.

Allow tall windows to move past the top of the screen

Sooner or later you’re going to run into a window that is too tall to display on the 9" screen, and cannot be resized. The solution is to open up a terminal and run this command:

$ gconftool-2 —set /apps/compiz/plugins/move/allscreens/options/constrain_y —type bool 0

This will allow you to move these windows past the top of the screen (use ALT+Drag anywhere in the window. There are a number of other useful gconftool hacks on Ubuntu’s EeePC page.

Create $HOME/bin directory

You’re going to want a place to store little scripts and tools where they can be executed on the command line.

$ mkdir _/bin

Now add it to your PATH so bash can find it. Open up your ~/.bashrc file and append

if [ -d ~/bin ] ; then

  PATH=/bin:“${PATH}”

fi

Make the LCD ultra bright!

This hack is really cool. I found it on the EasyPeasy wiki. Create a new file called ultra-bright in $HOME/bin and paste in this line, then save.

sudo setpci -s 00:02.1 f4.b=ff

You will need to make it executable, so

$ chmod +x ~/bin/ultra-bright

Now you can run

$ ultra-bright

to turn on the extra brightness, and use the bright/dim function keys to reset it. If you’re like me, you’ll want the extra brightness turned on all the time, so go ahead and create an entry for it in Preferences > Sessions.

Enable the WiFi / Bluetooth / webcam toggle and performance tuner

For this you’ll need a package called eee-control. You’ve already installed the Eee kernel, so this package should be available to you from the repository you added to your Software Sources.

$ sudo apt-get install eee-control

Alternatively, you can download the Ubuntu package from the website.

Now you can find this nifty utility in your Administration menu. Unless you need the extra battery life, I recommend setting performance to “super”. To make use of your webcam, install the cheese and/or skype packages.

Make sure text is being rendered crystal clear

Open Preferences > Appearance > Fonts and select “Subpixel smoothing (LCDs)”. Then click Details… and set Hinting to “Full”. If you’re like me you absolutely hate Ubuntu’s default monospace font. I prefer Terminus. To switch, install the xfonts-terminus package and make it the default Fixed Width font.

Boost GNOME Performance with /etc/hosts

Following this guide will help improve your system performance, and it takes about 2 seconds.

Installing Avant Window Navigator

AWN is similar to the Dock on Mac OS X.

$ sudo apt-get install avant-window-navigator

Right-click the panel at the bottom of your screen and check “Allow Panel to be Moved”. Drag it to the top of your screen, right-click and lock it again. Now launch Accessories > Avant Window Navigator. It’s kind of ugly and huge by default, but we can fix that.

Right-click on AWN and click Preferences. Turn on “Auto hide bar when not in use”, then switch to the Bar Appearance tab and change Bar Height to something more reasonable, like 32.

Now you’ll want to get rid of the Window List at the top of the screen. Right-click on it and select “Remove from Panel”. Gone! Now there is lots of room for program shortcuts and silly panel applets.

That’s it!

You now have a usable OS on your Asus EeePC, which means you are both cooler and more attractive than every other clown with a clunky Xandros-based netbook. Thanks for following my guide. Let me know in the comments section how your installation experience went and if you have any other EEE tricks worth sharing.

slashhardcore.rb is a station tuner for Digitally Imported radio

2007-08-29T00:00:00-07:00

slashhardcore.rb is a station tuner for Digitally Imported radio

29 Aug 2007

I updated this script! Forgot to bind the /hardcore command before. Grab it now!

I was surprised how easy it is to write an XChat plugin in Ruby, even though it would be cooler to see a the xchat-ruby bindings pimped out DSL style…oh well.

Download slashhardcore.rb

Windows users must modify @launcher to the path to their Winamp, Firefox, IE, or other shoutcast-compatible player.


# slashhardcore.rb - A faster way to tune in than the playlist bot.
# Should work on Windows if you set a valid browser/winamp location.
#
# Usage: Put in your $HOME/.xchat2 directory to autoload, and restart xchat,
# or type "/load /path/to/slashhardcore.rb"
#
# Commands: /pls <station, /stations (list stations), /hardcore
#
# Author: Logan Koester <logan@logankoester.com>

include XChatRuby

class SlashHardcore < XChatRubyPlugin

	attr_accessor :launcher

	def initialize( plugin )
		@launcher = "/usr/bin/firefox"
		hook_command( "pls", XCHAT_PRI_NORM,
			method ( :pls ),
			"Use /pls <station> to tune in. Use /stations to check list
			of stations at di.fm"
		)
		hook_command( "stations", XCHAT_PRI_NORM,
			method ( :stations_list ),
			"Fetches an updated list of DI.fm stations"
		)
		hook_command( "hardcore", XCHAT_PRI_NORM,
			method ( :hardcore ),
			"Tunes into the happyhardcore.com radio stream"
		)
		puts_fmt "Digitally Imported!"
	end

	# Alias for /pls hardcore
	def hardcore (words, words_eol, data)
		puts_fmt "Hardcore is good for you!"
		play "hardcore"
		return XCHAT_EAT_ALL
	end

	# Tunes you in using your browses's default application
	# for *.pls files
	def pls (words, words_eol, data)
		station = words[1]
		puts_fmt "Tuning into #{station} (using #{@launcher})"
		@plugin.command( "/msg #candyball test" )
		play station
		return XCHAT_EAT_ALL
	end

	def play (station)
		exec "#{@launcher} http://di.fm/mp3/#{station}.pls" if fork == nil
	end

	# Returns the playlist filenames of playlists at di.fm
	def stations_list (words, words_eol, data)
		require 'open-uri'
		uri = "http://www.di.fm/mobile/?type=mp3"
		index = URI.parse uri
		list = index.read.to_s.scan(/="\/mp3\/(.*)\.pls/).flatten
		puts_fmt list.join ", " # CSV string
		return XCHAT_EAT_ALL
	end
end

Logan Koester

errship

errship

Soonatra - 'Coming Soon' pages on Sinatra

Soonatra - ‘Coming Soon’ pages on Sinatra

FeedzirraRedis

FeedzirraRedis

Installation

A Dynamic DNS client in Ruby

A Dynamic DNS client in Ruby

Installation

Usage

Switching to Jekyll

Switching to Jekyll

Bundler + Watchr

Bundler + Watchr

Does it take you a while to get started in the morning?

Does it take you a while to get started in the morning?

Planning

Planning

Bayesian Classification on Rails

Bayesian Classification on Rails

Fun with ion3

Fun with ion3

Installation

Modifying your configuration

Remapping Mod1

Human Readable Text Compression

Human Readable Text Compression

As a Web Service

From the command line

From vim

On the Web

PingLater.fm

PingLater.fm

Deploying Sinatra to a sub-URI using Passenger

Deploying Sinatra to a sub-URI using Passenger

Setting up rTorrent with Firefox

Setting up rTorrent with Firefox

Part 1 – rTorrent

Part 2 – Save Link In Folder

Links

TweetShrink gem for Ruby

TweetShrink gem for Ruby

Installing Linux Mint 6 on your Asus EeePC 901

Installing Linux Mint 6 on your Asus EeePC 901

Install Linux Mint

Install the EeePC kernel

Enable Desktop Effects

Allow tall windows to move past the top of the screen

Create $HOME/bin directory

Make the LCD ultra bright!

Enable the WiFi / Bluetooth / webcam toggle and performance tuner

Make sure text is being rendered crystal clear

Boost GNOME Performance with /etc/hosts

Installing Avant Window Navigator

That’s it!

slashhardcore.rb is a station tuner for Digitally Imported radio

slashhardcore.rb is a station tuner for Digitally Imported radio