Curiouser and Curiouser! on ruby

It's not quite Ruby.NET but...

Tue, 19 Apr 2005 12:46:01 +0100

A Bishop and a Reverend walk into a bar

Sun, 24 Apr 2005 21:59:29 +0100

Last weekend I ported the Reverend bayesian classifier from Python to Ruby (thanks Jon for the original pointer to Reverend). What I didn't realise was that Lucas Carlson was, simultaneously, working a similar library... ah well, there's a good chance we'll roll my work into his more general classifier library.

Anyway for what it's worth my port, Bishop, is available for download and as a RubyGem. I anticipate at least one more release before deciding what to do with it.

Stemmer gem

Sun, 24 Apr 2005 22:03:00 +0100

The unreleased version of Bishop uses Ray Pereda's port to Ruby of Martin Porter's word stemming algorithm.

I've used this code before and I noticed Lucas uses the same code. Despite it's size it made sense to us to package it as a RubyGem so that others could make use of it without duplication. Thanks to a suggestion by Lucas it's also going to be easy to plugin other stemmers later.

It's a fine ART

Wed, 04 May 2005 11:01:50 +0100

Something I was messing around with at the weekend is a Ruby implementation of the ART-1 and ART-2 clustering algorithms. ART stands for Adaptive Resonance Theory. I have no idea what "adaptive resonance" means but that hasn't stopped me so far.

Basically, what the ART family of algorithms do is partition a series of vectors (whose elements represent features of some subject) into a number of clusters (sets) where the features of the vectors in one cluster are "closer" to the centre of that cluster than they are to the centre of any other cluster.

The centre of a cluster is a mathematical point which depends upon a function of the features of the vectors in the cluster. As the centre moves vectors may drift between clusters accordingly.

ART-1 clusters boolean vectors (that is each feature is either on or off) while ART-2 clusters real valued vectors. It's ART-2 i'm primarily interested in as I'm looking at concept clustering in weblog posts as part of MemeScope. I went back and did ART-1 for completeness. Both will be released soon.

Different clusterings can be obtained by adjusting parameters to the algorithm. This is much like a b-tree where each bucket can have a different number of keys leading to different shaped trees. My perception is that, for ART-2 to be useful to me, I will need to find a good way of dynamically adjusting the parameters and reclustering as new data appears.

The first thing I need to do is to prove that my implementations are sound. I developed my ART-2 implementation from reading an outline summary of the algorithm. I have a paper on ART-2 but frankly can't understand the math or the terminology. My ART-1 implementation was implemented with reference to the code in AI Application Programming (an excellent practical book on this subject).

What would really, really help me is a set of sample data with expected output. It's hard to write test cases for the algorithm when I don't know exactly what to expect. Can anyone help me? Or point me at someone who can?

Ruby

Thu, 12 May 2005 13:08:25 +0100

Ruby: less is more, in a most elegant fashion.

YARV is coming

Tue, 28 Jun 2005 09:09:17 +0100

Ko1 is (firmly) back in the saddle. I totally missed this message dated June 2nd, wherein he outlines the three plans for YARV between now and February 2006. [RedHanded]

Excellent news for Ruby fans everywhere.

Detecting Ruby platforms

Wed, 29 Jun 2005 10:52:18 +0100

I got bitten recently by some naive platform detection code for Ruby. Ruby defines a constant RUBY_PLATFORM which contains a string identifying the platform and many programs use regular expressions to parse this in the same way that Browser-Agent strings get parsed. It's not a precise science and I imagine the author of the code:

if RUBY_PLATFORM =~ /win/i

hadn't spent much time using a Mac or he'd have come across the platform string

powerpc-darwin-8.1.0

and realised it wasn't going to fly.

I had a look around for Ruby platform detection code and, whilst I found other people doing the same trick, I didn't find a library or a comprehensive attempt to cover available platforms. So I decided to give it a try and the current result is: platform.rb.

If you require 'platform' in your code it will define three constants:

Platform::OS
- :unix
- :win32
- :os2
- :vms
- and so on...
- :unknown
Platform::IMPL
- :macosx
- :linux
- :mingw
- and so on...
- :unknown
Platform::ARCH
- :powerpc
- :x86
- and so on...
- :unknown

If you're a Ruby coder please download this library and run it using:

ruby platform.rb

and check that it prints sensible values for your platform. If not please leave me a comment here with the output of

ruby -e "puts RUBY_PLATFORM"

and what you think should be the value for Platform::OS, Platform::IMPL, and Platform::ARCH. I'm also interested in any comments about other, potentially useful, things we can infer.

Once I have reasonable coverage I'll release it as a file download and a gem.

The Radio Event Horizon

Thu, 14 Jul 2005 12:08:30 +0100

I've wanted to move my blog from Radio for quite a while. It has served me well and I've had fun with it but I feel those days are gone. It's been a while since I saw Radio as a product with a viable future and I have no more interest in working with Usertalk despite having a number of blog ideas I'd like to develop.

However a working, developed, blog platform with a large chunk of content creates a pretty strong gravity well. Migrating to another product is going to be hard. I've not found a product which could give me the escape velocity I need.

I love working with Ruby. I'd love to have a blogging platform that was written in Ruby. But, then again, now that I have a Mac I can finally use Tinderbox and, apparently, Mark Bernstein is working on making Tinderbox a 1st class blogging tool.

Maybe this time next year I'll be using a new tool and developing new ideas again.

80% less crufty

Thu, 14 Jul 2005 12:38:08 +0100

About this time last year I was realising that Lisp probably wasn't the language for me. It introduced me to metaprogramming with macros, new ways of looking at OOP, and generally blew fuses in my mind. But it was also arcane and irregular. I could have handled the brackets if it were not for the generally cruftyness of the whole thing. Like Lucas I also found the naming ugly although I don't think his strategy of aliasing is going to work out unless he only deals with his own code.

I think that's why I like Ruby so much. It's full of metaprogrammingy goodness but with 80% less cruft. Also the regular syntax style makes it great for DSL's which is not, I would hazard, going to be the case for Lisp.

Cruftyness isn't everything

Fri, 15 Jul 2005 18:11:04 +0100

Ted Leung noticed my uninformed ramblings yesterday about Lisp not being a suitable language for DSL's whilst pointing to another post from someone reminiscing about using Lisp for this very purpose. He also points to a video of a Lisper building a little language for parsers.

I think my point about Lisp and DSL's was perhaps too strongly put. I guess what I was thinking was that I can imagine creating a DSL using Ruby which non-Ruby people could easily use. I think the ease with which PHP people start using Rails may be some small testament to this, or I may be stretching the evidence to fit my hypothesis.

So my point is that Lisp DSL's are probably only of use to Lisp hackers since the DSL looks like Lisp and Lisp is crufty! :-)

The video is really cool to watch though. It was very interesting to see someone so in command of his language go simply about solving a problem in this way. Worth watching whether you want to use Lisp or not.

So, to summarize, I still think Lisp is way cool and I bow to the mastery of the Lisp hacker. Nevertheless, you'll prize my copy of the PickAxe from my cold, dead, hand!

Ruby nearly ready to go VrooM

Mon, 15 Aug 2005 18:56:04 +0100

Resident Van Gogh of the Ruby world, Why the lucky stiff, reports that Rite and the RubyVM are coming ever closer

No need to patch Ruby HEAD yourself. Youre just a few paragraphs away from having your own little VM by your side. Keep in mind that this only builds miniruby, so were sort of still in the first trimester on this one. [RedHanded]

Excellent :-)

Checkpoint Charlie

Wed, 17 Aug 2005 16:42:04 +0100

Sam Newman is organizing a Rails & Django meet-up in Smithfields on September 5th. The idea is for Rails and Django folks to come together over beer and share ideas and perspectives. There'll likely be more Pythonistas so I hope they won't mind if the Rubyites bring water pistols (just kidding!)

l.m. hacks RSS and Atom while you wait

Wed, 14 Sep 2005 08:19:54 +0100

l.m.orchard has written a book about hacking RSS and Atom. I'm doing a lot of stuff with RSS parsing at the moment (right now I'm experimenting with Lucas Carlson's excellent SimpleRSS parser) so I might go pick up a copy, even if he does use Python ;-)

Another reason to love Ruby

Fri, 23 Sep 2005 11:16:55 +0100

RubyCon is a toolkit for building concept processing and other intelligent reasoning systems. A brief glance suggests similarities with Cyc which I have looked at before.

An interesting comparison is that RubyCon claims 170,000 concepts whilst OpenCyc (Cyc's open source cousin) claims 36,000. I wonder whether I'm comparing apples with apples and what the significance is?

Well, whatever, RubyCon looks very interesting and the Ruby interface is a compelling feature.

MacOSX on Rails

Thu, 29 Sep 2005 15:04:14 +0100

Any MacOSX users that want to give RubyOnRails a try might want to check out Ryan Raaum's Locomotive package. It's kind of a 1-click deal for Rails that includes Ruby, Rails, useful libs, and the SQLLite database (it also includes MySQL and Postgresql bindings if you have those already). I'm setup already but it looks kinda cool.

All your symbols are belong to us

Tue, 04 Oct 2005 10:43:12 +0100

I've now lost the trail of breadcrumbs which lead me here, but I just read an article by Brad Parker about his efforts to revive the code from one of the MIT Lisp machines. He and a co-conspirator have gotten an emulator running which allows the Lisp machine to boot and talk to the network.

Practical? No. But I find the idea of a Lisp machine (a computer which is Lisp from the hardware upwards) intriguing so it's an interesting slice of history.

If someone came up with a Lisp operating system for PC hardware I'd play with it. I guess a RubyMachine is too much to ask for :-)

Eat your heart out GreaseMonkey

Tue, 04 Oct 2005 19:17:54 +0100

It's amazing what the MouseHole web proxy can do:

See, heres some incredible advantages over Greasemonkey and any other competition Ive encountered. MouseHole allows user scripts to act as full web applications. In this case, the writeboard feeds are watched and applicable IDs and tokens are stored in the scripts own database. [RedHanded]

Models Reloaded!

Tue, 04 Oct 2005 21:55:28 +0100

One of the neat things about Rails is that you can open what's called the Developers Console (it's really irb) and interact directly with your ActiveRecord models. One nit is that, when you make changes, you need to exit and restart. Well not any more, thanks to Courtnay for this trick:

$ script/console
Loading development environment.
>> ..do stuff here..

then modify your model code..
then..

>> Dispatcher.reset_application!
models reloaded!

Sticking my head in the mouse hole

Wed, 05 Oct 2005 20:56:48 +0100

So, as an experiment, I have now setup MouseHole as a login item for my MacOSX account and set it up as a permanent proxy for Safari.

Eugh fresh mouse droppings

Thu, 06 Oct 2005 00:50:28 +0100

Just to make sure I get it I wrote my first mouse dropping this evening to go in my mouseHole. Called got-links (You can find it in the list of mouseHole User Scripts) it's very simple and silly. It just keeps a count of every site and url that you visit and lets you view the counters by going to sites and urls. Simple, neat, and all in lovely Ruby.

Talk to me Cocoa

Fri, 07 Oct 2005 09:26:58 +0100

One of the things I'm trying to work out is the best way to approach writing GUI apps with Ruby. There are a number of options including wxRuby, fxRuby, QTRuby, Ruby/tk, RubyCocoa, and so on. Since I'm really interested in an Aqua interface (for my own benefit) I narrowed the field to wxRuby and RubyCocoa. The latter looks especially promising to me although I'm not making much progress on it.

Today I came across CocoaDialog which might act as a neat stop-gap for some of my needs. It's designed to be called from a script that needs to get user input or present information. So in the same way that you can use ruby-growl to display notifications from a script, you can use CocoaDialog to collect input.

Instant Rails just add water!

Wed, 12 Oct 2005 08:52:43 +0100

Curt Hibbs (he of the excellent one-click Ruby installer for windows) has issued a preview release of his new package Instant Rails:

Instant Rails is a one-stop Rails runtime solution containing Ruby, Rails, Apache, and MySQL, all preconfigured and ready to run. No installer, you simply drop it into the directory of your choice and run it. It does not modify your system environment. See the Release Notes for a complete list of what is included.

The preview is Windows only but releases for other operating systems will follow.

Higher Order Messaging

Fri, 21 Oct 2005 11:22:25 +0100

Last night I read an excellent article by Nat Pryce about implementing Higher Order Messaging (HOM) in Ruby. A HOM is message that contains a message that is applied to a collection and rules for collating and returning the results. It's kind of like Enuermable#collect on steriods.

Here's how to implement this rule by explicitly iterating over the list of claimants using Ruby's for statement:
for claimant in claimants
    if claimant.retired? then
        claimant.receive_benefit 50
    end
end
Here's the same rule implemented with higher-order functions methods that accept a block:
claimants.select {|e| e.retired?}.each {|e| e.receive_benefit 50}
And finally here's the same rule implemented with higher order messages:
claimants.where.retired?.do.receive_benefit 50

Interesting stuff.

Here's why I haven't used Java in over a year

Fri, 28 Oct 2005 12:41:15 +0100

Why Ruby on Rails?.

Curiouser and Curiouser on Rails!

Fri, 18 Nov 2005 00:45:47 +0000

Okay the weblog is back in action, no longer being published using Radio but now using Squib which is my new open source weblog tool. It's heavily influenced by my 3 years of using Radio: like Radio, Squib is an application that runs on your computer and publishes a weblog to a remote server as a static set of pages (it talks to the Radio Community Server using the RCS upstreaming protocol). Unlike Radio, Squib is written in pure Ruby using the Rails framework and currently clocks in at around 1,000 lines total.

Right now it's in pretty rough shape and probably only usable by someone desparate to escape Radio (let's say maybe your copy of Radio kept upstreaming 0-length files) but wanting to keep compatibility with an existing Radio weblog (same permalinks, etc...)

Over the next couple of weeks I aim to fix the gaping holes. Source should be available from RubyForge any day now.

Intense Ruby!

Fri, 02 Dec 2005 14:43:25 +0000

Oh my goodness... Try Ruby... it's amazing!

Io, Io? What's all this then?

Fri, 30 Dec 2005 22:07:44 +0000

I've been casting about recently for the next language I will learn. I tried Lisp in 2004 and while it gave me a healthy respect for meta programming I didn't really click with it. Then in October 2004 I fell over Ruby one time too many and decided to give it a try. It was love at 3rd sight!

Over the last year I've spent quite a lot of my free time working in Ruby and it has been very rewarding. Recently I implemented the weblog tool I am using now with Ruby and Rails. I think Ruby is great.

However if learning Ruby has taught me anything it's that the greatest power has come from new ways to think about solving problems. For example I now routinely think in terms of blocks in a way I could never have conceived of when I was a Java developer. So, lately, I've started wondering what other tricks I can learn.

It has been on my mind for a while to try Smalltalk. Much like Lisp, Smalltalk is kind of revered as a hallowed and sacred language from which many good things we now enjoy have flowed. However I've seen some talk about Io lately and especially about the advantages of prototype based OO. Today Dave Fayram showed me some Io code that was very intriguing. I think Smalltalk is going to have to wait!

I've downloaded the Io binaries for MacOSX and an Io bundle for TextMate and over the weekend I hope to find enough time to learn some of the syntax and get a feel for the prototypy goodness.

Wish me luck!

ActiveRecord, Ruby 1.8.4, and GCC4

Mon, 16 Jan 2006 11:53:45 +0000

Yesterday was something of an exercise in frustration when I attempted to update my PowerBook to the latest and greatest Ruby 1.8.4. I use DarwinPorts so you'd think it would be easy but it's wasn't because (a) I didn't realise you had to manually use

sudo port sync

to get the list of ports to update (so I didn't realise they even had 1.8.4) and (b) various ports wouldn't update properly or compile.

In the end I ripped out my existing DarwinPorts installation, upgraded to the latest XCode 2.2, and began to rebuild. At the end I had 1.8.4 along with the relevant gems and extensions and it all seems fine. Squib is running okay using it.

However I notice that the ActiveRecord unit test suite is failing in some rather peculiar ways. Most of the errors relate to the non-existence of tables and rows which are there at the beginning of the test run (I verified that the executed DDL correctly created the tables). So it seems like something is dropping the tables and/or deleting rows as the tests execute. But if there was such a huge problem with Ruby/MySQL why is squib running okay? (Yes I am backing up my data!)

Where I do have cause for concern is the interplay between GCC v3.3 and GCC v4.0.1. When I tried building Ruby 1.8.4 just after the release (to help with Rails testing) it didn't seem to work properly using GCC4. The wisdom at that time seemed to be that something in the GCC4 compiler wasn't right and was building ruby improperly. So naturally I used

sudo gcc_select 3.3

before attempting to get the Ruby DarwinPort built. However when I came to testing the MySQL native extension I got a very unpleasant error:

dyld: NSLinkModule() error dyld: Symbol not found: _sprintf$LDBLStub Referenced from: /opt/local/lib/ruby/gems/1.8/gems/mysql-2.7/lib/mysql.bundle Expected in: flat namespace Trace/BPT trap

The general wisdom seemed to be that this was an error caused by compiling with GCC4 but I was compiling with GCC3! In desparation I tried using GCC4 and it worked!

But now I have Ruby compiled with GCC3 and various native bits and pieces with GCC4 and it does not make me happy or comfortable that everything will be okay. Especially in the light of the unit test failures in ActiveRecord.

I'd be interested in hearing from anyone else whose tried these tests. Maybe there is something amiss with them.

Overall I'm left with the feeling that Ruby 1.8.3 and 1.8.4 could have been smoother. And was it beyond Apple just to fix the Ruby install that came with Tiger in the first place?

You're not seeing me from my best side

Thu, 19 Jan 2006 13:55:27 +0000

Ugh:

Irulan:~/Projects/squib matt$ action_profiler WelcomeController#index
WARNING: overridding NODE *
/opt/local/lib/ruby/siteruby/1.8/rubygems/customrequire.rb:27: [BUG] Bus Error
ruby 1.8.4 (2005-12-24) [powerpc-darwin8.3.0]
Abort trap

That's not what I wanted to see. Yet ZenProfiler is working:

Irulan:/opt/local/lib/ruby/gems/1.8/gems/ZenHacks-1.0.1 matt$ sh zenprofile-demo.sh 
zenspider profiler:
Iter = 5000, T = 0.70851300 sec, 0.00014170 sec / iter
  %   cumulative   self              self     total
 time   seconds   seconds    calls  ms/call  ms/call  name
100.00     0.61      0.61        1   610.00   610.00  Range#each
 90.16     1.16      0.55     5000     0.11     0.11  Factorial#factorial
 77.05     1.63      0.47     5000     0.09     0.09  Integer#downto
 16.39     1.73      0.10        1   100.00   100.00  dummy
 16.39     1.83      0.10    20000     0.00     0.00  Fixnum#*
  0.00     1.83      0.00        1     0.00     0.00  Fixnum#to_s
  0.00     1.83      0.00        1     0.00     0.00  ZenProfiler#instance
  0.00     1.83      0.00        2     0.00     0.00  Time#initialize
  0.00     1.83      0.00        1     0.00     0.00  String#to_i
  0.00     1.83      0.00        1     0.00     0.00  Object#initialize
  0.00     1.83      0.00        1     0.00     0.00  IO#write
  0.00     1.83      0.00        1     0.00     0.00  Time#-
  0.00     1.83      0.00        1     0.00     0.00  Module#method_added
  0.00     1.83      0.00        1     0.00     0.00  Float#/
  0.00     1.83      0.00        1     0.00     0.00  Array#shift
  0.00     1.83      0.00        2     0.00     0.00  Time#now
  0.00     1.83      0.00        1     0.00     0.00  Class#new
  0.00     1.83      0.00        1     0.00     0.00  Kernel.printf
  0.00     1.83      0.00        1     0.00   610.00  #toplevel
  0.00     1.83      0.00        1     0.00     0.00  Class#inherited

real    0m1.631s
user    0m0.704s
sys     0m0.295s

I did wonder about the witches brew that I ended up with when getting Ruby 1.8.4 via DarwinPorts. Damn.

RubyInside

Tue, 30 May 2006 09:58:34 +0100

Peter Cooper has created a stylish new aggregator blog RubyInside where he is highlighting interesting stuff going on with Ruby. I read quite a few Rubyist blogs but can't keep up with them all and appreciate a commentary from someone like Peter about what's worth knowing.

Why I love Ruby so much

Mon, 17 Jul 2006 23:44:47 +0100

module Enumerable
    # return a new array of tuples where each element of this array
    # is matched with each element of the other array
    def permute( other )
        self.inject( [] ) do |container,element|
            container | Array.new( other.size, element ).zip( other )
        end
    end

    # Return a map using a new Thread to compute each mapped value asynchronously
    def map_asynch( &block )
        self.map { |element| Thread.new { block.call( element ) } }.map { |thread| thread.value }
    end
end

I'm particularly pleased with how simple the asynchronous map turned out to be and the fact that it becomes available to any Enumerable is gravy.