Here is the direct YouTube link

Don’t worry its not Rails or even Ruby loaded. The keynote goes through an interesting history of programming languages and on route Robert mentions Fortran, Lisp, Algol, BASIC, Simula, BCPL, B, C, Scheme, Smalltalk, C++, Perl, Java, Ruby, Erlang, C#, F#, Haskell and Clojure.

Hopefully I didn’t miss one? Strangely can’t recall Python being mentioned!?

/I3az/

Some examples from blog post:

# display this JSON request
puts http://github.com/defunkt.json

# => "He nose the truth."
require 'json'
url = http://twitter.com/statuses/show/6592721580.json
JSON.parse(url.to_s)['text']   

Very clever indeed. Of course there will be some edge cases but it does show you how far you can stretch Ruby. NB. Didn’t work in 1.9 for me but worked with minor warning in 1.8.2 (yes I know it old but thats what shipped with Mac OSX Tiger).

So how far can we stretch Perl? Well with Devel::Declare it can be stretched all the way:

use Modern::Perl;
use JSON qw(decode_json);
use URLDSL;

# print the json
say http://twitter.com/statuses/show/6592721580.json;

# => "He nose the truth."
say decode_json( http://twitter.com/statuses/show/6592721580.json )->{text};

So Perl also has no strings attached

Devel::Declare allow us to extend the Perl syntax in a robust and easy fashion:

package URLDSL;
use Modern::Perl;
use Devel::Declare ();
use LWP::Simple ();
use base 'Devel::Declare::Context::Simple';

sub import {
    my $class  = shift;
    my $caller = caller;
    my $ctx    = __PACKAGE__->new;
    
    Devel::Declare->setup_for(
        $caller,
        { 
            http => { 
                const => sub { $ctx->parser(@_) },
            },
        },
    );
    
    no strict 'refs';
    *{$caller.'::http'} = sub ($) { LWP::Simple::get( $_[0] ) };
}

sub parser {
    my $self = shift;
    $self->init(@_);
    $self->skip_declarator;          # skip past "http"

    my $line = $self->get_linestr;   # get me current line of code
    my $pos  = $self->offset;        # position just after "http"
    my $url  = substr $line, $pos;   # url & everything after "http"
    
    for my $c (split //, $url) {
        # if blank, semicolon or closing parenthesis then no longer a URL
        last if $c eq q{ };
        last if $c eq q{;};
        last if $c eq q{)};
        $pos++;
    }    
    
    # wrap the url with http() sub and quotes
    substr( $line, $pos,          0 ) = q{")};
    substr( $line, $self->offset, 0 ) = q{("http};
    
    # pass back changes to parser
    $self->set_linestr( $line );

    return;
}

1;

Here is a low level synopsis of how it worked:

• Devel::Declare tells the perl parser to call parser() when it hits http keyword
• http://twitter.com/statuses/show/6592721580.json example triggers this (perl has no problem naturally distinguishing “http” keyword from “http://”)
• Get line of code in question (my $line = $self->get_linestr; )
• parser() skips along the URL data following “http” ($self->offset) until it reaches a space, semicolon or a closing bracket (this covers “most” cases though comma could be an issue). This marks the end of the URL data
• We now in essence change http://twitter.com/statuses/show/6592721580.json into http("http://twitter.com/statuses/show/6592721580.json")
• And plonk the changed line back to the parser ($self->set_linestr($line);) and let it continue along its merry way
• NB. http() sub was already imported into calling space and returns a LWP::Simple::get of the requested URL

Now is URLDSL useful in the real world? It can screw up syntax highlighting a bit (though WordPress highlighter coped extremely well, unlike Github

Its robust enough to cope with normal string interpolation:

my $id = '6592721580';
say decode_json( http://twitter.com/statuses/show/$id.json )->{text};

So perhaps I should upload it to CPAN? (earmarked for ACME:: perhaps!?). Anyone think this is useful little helper module then I wrap it up the next time I get a free moment.

The exercise as been fruitful in allowing me to get my head into the amazing Devel::Declare module for the first time.

I’ve used the Devel::Declare::Context::Simple class which simplifies things. Unfortunately there isn’t a POD on this yet but the main Devel::Declare docs nicely demonstrate the correct mechanics so its easy to adapt from this.

I also found this blog post by franck cuny to be extremely helpful. As was delving through the source code of other modules that used Devel::Declare

/I3az/

s = "The green hat is the twin of the green hat"
h = Hash.new(0)
s.split.each do |w|
  h[w.downcase] += 1
end

If you know Ruby then you know this isn’t very idiomatic. Here is something closer to would normally see in Ruby world:

h = s.downcase.split.inject(Hash.new(0)) { |h,k| h[k] += 1; h }

But the style of the original code is something I’ve seen often in Perl:

my $s = "The green hat is tHe twin of the green hat";
my %h; 
for my $w (split /\s+/, $s) {
    $h{ lc $w }++;
}

Now if brevity was key to better code then you could do this:

my %h; $h{$_}++  for split /\s+/, lc $s;

But I think its better to do something like this:

my %words = do { 
    my %h;
    $h{$_}++  for split /\s+/, lc $s;
    %h;
};

OK this is not a great example of do blocks and isn’t even as DRY compared to original code. But I do find this more aesthetic IMHO.

Perhaps a better example of what do blocks can do is to produce another naff example!

my $num_string = do {
    my $num = get_random_num_between_1_and_3();
    if    ($num == 1) { 'one' }
    elsif ($num == 2) { 'two' }
    elsif ($num == 3) { 'three' }
};

do blocks return the last evaluated result. And result can be plural:

my $year = get_year();
my ($champions, $runners_up) = do {
    if    ($year == 2003) { ('England', 'Australia')    }    
    elsif ($year == 2007) { ('South Africa', 'England') }
};

say "Rugby World champions for $year: $champions  Runners up: $runners_up";

So do blocks are useful tools in helping to make code more focused and avoid unnecessary pollution of variables into calling namespace.

But we can either move up another notch by using anonymous subroutines:

my ($champions, $runners_up) = sub {
    given ($_[0]) {
        when (2003) { return ('England', 'Australia')    }
        when (2007) { return ('South Africa', 'England') }
    }
}->( get_year() );

This anon sub block is built and then immediately executed by the ->() bit.

So works much like a do block except we can short circuit flow with return thus enabling us more freedom and control over what these blocks of code can do.

Using do / anon sub blocks is something that Perl can definitely learn from Ruby. Here is another recent example of do usage that I like a lot (see has).

NB. Another advantage of the do / anon sub block approach is that at anytime the block gets big or its needed elsewhere then it doesn’t take much to turn it into a proper subroutine.

I’ll end with my obligatory autobox solution of the original code:

my $s = "The green hat is tHe twin of the green hat";

my %words = $s->lc->split( qr{\s+} )->hash_count->flatten;

sub autobox::Core::ARRAY::hash_count {
    my $list = shift;
    my %h;
    $h{$_}++ for @$list;
    \%h;
}

You can even do:

'The green hat is the twin of the green hat'->lc->split( qr{\s+} )->hash_count->flatten;

But I can’t think where something like this would ever be useful in the real world? Though it is nice to look at when running it via the extremely useful Devel::REPL

/I3az/

Still this recent Hacker News post about Python vs Clojure did catch my eye.

Despite the fact the author of the blog post had pulled the Python code from answers to Project Euler the pythonista’s quite correctly cried foul because it wasn’t well written idiomatic python example and so was an unfair comparison.

There’s a lot of code out there posted on those intertubes over the years. However languages and practises evolve but unfortunately intertube posts can remain set in stone! Perl is often weighed down by its past history on the intertubes. One good way forward is just to produce more Modern Perl posts.

Anyway i digress, so moving on lets take a look at the Euler 4 – Finding Palindroms. This was the Clojure example that was put forward in the blog post:

(reduce max
    (filter #(let [s (str %)]
               (= (seq s) (reverse s)))
            (for [x (range 100 1000)
                  y (range 100 1000)]
              (* x y))))

Now in reply to this a much more idiomatic python example was provided:

print max(s for s in (x * y 
    for x in range(111, 1000) 
    for y in range(x, 1000))
    if list(str(s)) == list(reversed(str(s))))

This uses Python’s list comprehension. Definitely a very powerful construct. However i do find i get lost very quickly when trying to follow long nested comprehension’s

In this same Python post there is also mention of a twitter post by Yukihiro Matz, the creator of Ruby. Matz provided the following Ruby example:

p [*100..1000].product([*100..1000]).map{|x,y| x*y}.select{|s|s=s.to_s; s==s.reverse}.max

Despite being formatted for twitter (ie. one line) i found it easy to follow through the logic.

Ruby & Python are not the only languages that can produce an elegant solution! So not to be out done here is a Perl example. In fact its the exact same code repeated three times but formatted differently:

use Modern::Perl;
use List::Util q(max);

# twitter one liner
say max grep { $_ eq reverse $_ } map { my $x = $_; map { $x * $_ } 100..1000 } 100..1000;


# again in lispy style format
say 
  max 
    grep { $_ eq reverse $_ } 
      map {
        my $x = $_;
        map { $x * $_ } 100..1000;
      } 100..1000;

# and finally in my preferred more perlish alignment
say max 
    grep { $_ eq reverse $_ } 
    map {
        my $x = $_;
        map { $x * $_ } 100..1000;
    } 100..1000;

The perl code speaks for itself.. its wonderfully clear and succinct. Also its fast, each version runs in under a second on my machine!

/I3az/

Alongside them are my two conversions written in Squatting, a Camping-inspired Web Microframework for Perl, written by John Beppu

The Camping Short, Short Example:

require 'camping'

Camping.goes :HomePage

module HomePage::Controllers

  # The root slash shows the `index' view.
  class Index < R '/'
    def get
      render :index 
    end
  end

  # Any other page name gets sent to the view
  # of the same name.
  #
  #   /index -> Views#index
  #   /sample -> Views#sample
  #
  class Page < R '/(\w+)'
    def get(page_name)
      render page_name
    end
  end

end

module HomePage::Views

  # If you have a `layout' method like this, it
  # will wrap the HTML in the other methods.  The
  # `self << yield' is where the HTML is inserted.
  def layout
    html do
      title { 'My HomePage' }
      body { self << yield }
    end
  end

  # The `index' view.  Inside your views, you express
  # the HTML in Ruby.  See http://code.whytheluckystiff.net/markaby/.
  def index
    p 'Hi my name is Charles.'
    p 'Here are some links:'
    ul do
     li { a 'Google', :href => 'http://google.com' }
     li { a 'A sample page', :href => '/sample' }
    end
  end

  # The `sample' view.
  def sample
    p 'A sample page'
  end
end

The Squatting Short, Short Example:

use strict;
use warnings;

{
  package ShortShortExample;
  use base 'Squatting';
}

{
  package ShortShortExample::Controllers;
  use Squatting ':controllers';
  
  our @C = (

    C( 
      Index => [ '/' ],
      get   => sub {
        my ( $self ) = @_;
        $self->render( 'index' );
      },
    ),
    
    C(
      Page => [ '/(\w+)' ],
      get  => sub {
        my ( $self, $page_name ) = @_;
        $self->render( $page_name );
      }
    ),
    
  );
}

{
  package ShortShortExample::Views;
  use Squatting ':views';
  use HTML::AsSubs;
    
  our @V = (
    
    V(  'html',
      
      layout => sub {
        my ( $self, $v, @yield ) = @_;
        html(
          title ( 'My HomePage' ),
          body ( @yield ),
        )->as_HTML;
      },
      
      index => sub {
        my ( $self, $v ) = @_;
        return (
          p ( 'Hi my name is Charles.' ),
          p ( 'Here are some links:'   ),
          ul (
            li ( a( { href => 'http://google.com' },  'Google' ) ),
            li ( a( { href => '/sample' },  'a sample page'    ) ),
          ),
        );
      },
      
      sample => sub {
        my ( $self ) = @_;
        p ( 'A sample page' );
      },
            
    ),
  );
}

1;

The Camping Tutorial Two:

require 'camping'

Camping.goes :Nuts

module Nuts::Controllers
  class Index < R '/'
    def get
      @t = Time.now.to_s
      render :sundial
    end
  end
end

module Nuts::Views
  def layout
    html do
      head do
        title { "Nuts And GORP" }
      end
      body { self << yield }
    end
  end

  def sundial
    p "The current time is: #{@t}"
  end
end

The Squatting Tutorial Two:

use strict;
use warnings;

{
  package Nuts;
  use base 'Squatting';
}

{ 
  package Nuts::Controllers;
  use Squatting ':controllers';
  
  our @C = (
    C(
      Index => [ '/' ],
      get   => sub { 
        my ( $self ) = @_;
        my $v = $self->v;
        $v->{t} = localtime;
        $self->render( 'sundial' );
      },
    ),
  );
}

{
  package Nuts::Views;
  use Squatting ':views';
  use HTML::AsSubs;
  
  our @V = (
    V(  'html',
    
      layout => sub { 
        my ( $self, $v, @yield ) = @_;
        html (
          head ( 'Nuts And GORP' ),
          body ( @yield ),
        )->as_HTML;
      },
      
      sundial => sub {
        my ( $self, $v ) = @_;
        p ( "The current time is: $v->{t}" );
      },
    ),
  );
}

1;

I’m not going to say much more at this point because I think the code above clearly expresses what’s going on. So just enjoy

/I3az/

Postscript:

The two Camping tutorials were written by Why the lucky stiff the author of Camping. These are no longer available on web because _why was regurgitating them from his own repo/website onto GitHub.

I wrote the Squatting ports of the tutorial back in October 2008 so luckily I had pulled down these Camping tutorials. I found that porting _why’s excellent Camping tutorials were a good way of learning Squatting.

The plan was always to post these on my blog. In fact I have a long list of stuff to post ranging from just a few scribbles to completed prose. I’m just trying to be “logical” about the order of these posts!

So why (excuse the pun!) post these now? The reason will be obvious to most readers…. _why’s strange disappearance from the web overnight.

I not going to conjecture further but I hope all is OK. So this post is my little ode to _why.

Below are some links on this strange event:

• _why is no more (Hacker News)
• _why’s best twitter posts (Hacker News)
• Eulogy to _why (John Resig)

]]> http://transfixedbutnotdead.com/2009/08/20/why-squatting/feed/ 0 draegtun http://transfixedbutnotdead.com/2009/06/03/using-moose-roles-to-create-singleton-methods/ http://transfixedbutnotdead.com/2009/06/03/using-moose-roles-to-create-singleton-methods/#comments Wed, 03 Jun 2009 14:14:09 +0000 draegtun http://transfixedbutnotdead.com/?p=388 ]]> Randal Schwartz recently posted this bit of Smalltalk code on his Methods and Messages blog

p := 4 @ 3.
p changeClassTo: (p class copy superclass: p class).
p class methodDictionary at: #negated put: (p class methodDictionary at: #transpose).
p negated


My exposure to Smalltalk is limited to a quick look at Seaside web framework which is a bit like learning Rails instead of starting with Ruby

I can just about grok what this code does. Thankfully Rick DeNatale provided a nice Ruby conversion

Here is Rick’s subset of Smalltalk’s Point which replicates what the first Smalltalk line “p := 4 @ 3.” does:

class Point
  attr_accessor :X, :y    # :X should be lowercase but Wordpress keeps converting it to a smiley!

  def initialize(x, y)
    @x, @y = x, y
  end

  def negated
    self.class.new(-x, -y)
  end

  def transpose
    self.class.new(y, x)
  end

  def inspect
    "#{@x} @ #{@y}"
  end
end


p = Point.new(4,3)

p.negated          # => -4 @ -3
p.transpose        # => 3 @ 4

So negated & transpose methods return new Point objects so all very straightforward so far.

In the Smalltalk code the object negated method gets amended to use the transpose method instead.
You can do this in Ruby by opening up the objects method like so:

def p.negated
  transpose
end

p.negated          # => 3 @ 4
p.transpose        # => 3 @ 4

Nice eh! The Ruby world refer to this has a Singleton Method. These are methods which are defined in the object and not the class.

I highly recommend watching this excellent video talk by Dave Thomas which provides excellent lucidity to how Ruby objects work.

Now how about Perl? I suspect you can use some MOP meta magic to do same but did you know that Moose Roles can be applied directly to objects?

Here’s is the Ruby Point code in Perl using classic Moose.


{
    package Point;
    use Moose;

    has x => ( isa => 'Int', is => 'rw' );
    has y => ( isa => 'Int', is => 'rw' );

    sub negated {
        my $self = shift;
        $self->new( x => -$self->x, y => -$self->y );
    }

    sub transpose {
        my $self = shift;
        $self->new( x => $self->y, y => $self->x );
    }

    sub inspect { say "$_[0]->{x} \@ $_[0]->{y}" }
    
    no Moose;
}


my $p = Point->new( x => 4, y => 3 );

$p->negated->inspect;     # => -4 @ -3
$p->transpose->inspect;   # => 3 @ 4

So all works same as the Ruby example. Now if we create a role like so:

{
    package Negated;
    use Moose::Role;
    
    requires 'transpose';
    
    sub negated { 
        my $self = shift;
        $self->transpose;
    }
    
    no Moose::Role;
}

You can then “apply” it to any object like so:


Negated->meta->apply( $p );
$p->negated->inspect;     # => 3 @ 4
$p->transpose->inspect;   # => 3 @ 4

Lovely jubbly!

And as we’ve gone down this Moose Role route we might as well wrap it all up like this:


{
    package Point;
    use Moose;

    with qw/DoesNegated DoesTranspose/;
    
    has x => ( isa => 'Int', is => 'rw' );
    has y => ( isa => 'Int', is => 'rw' );

    sub inspect { say "$_[0]->{x} \@ $_[0]->{y}" }
    
    no Moose;
}

{
    package DoesNegated;
    use Moose::Role;
        
    sub negated {
        my $self = shift;
        $self->new( x => -$self->x, y => -$self->y );
    }
    
    no Moose::Role;
}

{
    package DoesTranspose;
    use Moose::Role;
        
    sub transpose {
        my $self = shift;
        $self->new( x => $self->y, y => $self->x );
    }
    
    no Moose::Role;
}

my $p = Point->new( x => 4, y => 3 );

DoesTranspose->meta->apply( $p, alias => { transpose => 'negated' } );

$p->negated->inspect;     # => 3 @ 4
$p->transpose->inspect;   # => 3 @ 4

This time I used the “alias” option to rename the applied method on the Moose hoof

And u can keep applying roles to objects at your hearts content adding or replacing methods
as many times as u like.

/I3az/

Some references:

• Moose Cookbook Roles Recipe 3
• my Stackoverflow answer about applying roles on objects

]]> http://transfixedbutnotdead.com/2009/06/03/using-moose-roles-to-create-singleton-methods/feed/ 12 draegtun http://transfixedbutnotdead.com/2009/01/14/new-year-resolutions/ http://transfixedbutnotdead.com/2009/01/14/new-year-resolutions/#comments Wed, 14 Jan 2009 11:25:13 +0000 draegtun http://draegtun.wordpress.com/?p=146 ]]> Actually I’m not into New Year Resolutions… so there goes that title

However I wanted to revisit and re-emphasise why I’m blogging

Bit of back history… programming as always been the thing I’ve enjoyed most however I’ve often been diverted (far too easily!) by other things (including being an I.T. Manager for some years & doing an unsuccessful CRM start up with a partner).

When I became a freelance consultant back in 2002 my aim was to get back into the nitty gritty of programming. However I was still being pulled in other I.T. & Market Research directions. So when I started this blog back in August 2006 it was like putting a line in the sand.

During all this time Perl was my main programming language of choice. However I did very briefly dabble in Python on couple of projects and also had a short term love affair with Ruby (don’t we all!).

In fact more than anything it was this Ruby affair that made me put a line in the sand back in 2006. Perl was always the bread winner but Ruby showed me that Perl was also fun again like it was when I first picked it up back in 1995.

So my “New Year Resolution” is to keep on this track and blog more about what I’m doing with Perl. I find the best way to improve and/or learn something new is to do it. Second best way is to document it (ie. blog). And the by-product of this is an excellent resource to fall back to especially has my memory isn’t what it use to be!

I’ll do my best not to get distracted while on route

/I3az/


]]> http://transfixedbutnotdead.com/2009/01/14/new-year-resolutions/feed/ 4 draegtun http://transfixedbutnotdead.com/2008/12/05/lucky_to_have_perl/ http://transfixedbutnotdead.com/2008/12/05/lucky_to_have_perl/#comments Fri, 05 Dec 2008 23:55:28 +0000 draegtun http://draegtun.wordpress.com/?p=65 ]]> After a bit of doom & gloom over last few days on use.perl.org at least we can have a warm feeling about things we take for granted in the Perl world….

 http://drnicwilliams.com/2008/12/05/my-rubygems-development-tools-and-workflow/

/I3az/


]]> http://transfixedbutnotdead.com/2008/12/05/lucky_to_have_perl/feed/ 0 draegtun http://transfixedbutnotdead.com/2008/10/21/using-template-toolkit-with-squatting/ http://transfixedbutnotdead.com/2008/10/21/using-template-toolkit-with-squatting/#comments Tue, 21 Oct 2008 12:04:53 +0000 draegtun http://draegtun.wordpress.com/?p=45 ]]> Been playing with Squatting recently. Its a Perl Web microframework inspired by Camping. For someone like me who is still converting some old CGI apps to Catalyst then this looks like an interesting alternative.

I use Template Toolkit quite a bit so here’s a boilerplate for using TT with Squatting…..

use strict;
use warnings;

{
    package App;
    use base 'Squatting';

    BEGIN {
        our %CONFIG = (
            TT => {
                config   => { INCLUDE_PATH => '.' },
                postfix  => '.tt',
                site_tit => 'TT loves Squatting!',
            }
        );

    }
}

{
    package App::Controllers;
    use Squatting ':controllers';

    our @C = (

        C(
            Home => [ '/' ],
            get  => sub {
                my ( $self )  = @_;
                my $v         = $self->v;
                $v->{ tit }   = 'welcome to my homepage';
                $self->render( 'home' );
            },
        ),
        
        C(
            Page => [ '/path/to/page' ],
            get  => sub {
                my ( $self ) = @_;
                my $v        = $self->v;
                $v->{ tit  } = 'here is another page!';
                $v->{ list } = [ 'one', 'two', 'three' ];
                $self->render( 'page' );
            },
        ),

    );
}

{
    package App::Views;
    use Squatting ':views';
    use Template;

    our @V = (

        V(
            'html',
            tt => Template->new( $App::CONFIG{ TT }->{ config } ),

            layout => sub {
                my ( $self, $v, $body ) = @_;
                my $tt = $self->{ tt };
                $v->{ site_tit } = $App::CONFIG{ TT }->{ site_tit };
                $v->{ body     } = $body;
                
                my $output;
                $tt->process( 'layout'. $App::CONFIG{ TT }->{ postfix }, $v, \$output)
                    or return view_error( $tt->error );
                return $output;
            },

            _ => sub {
                my ( $self, $v ) = @_;
                my $tt = $self->{ tt };
                $v->{ R } = \&R;
                
                my $output;
                $tt->process( $self->{template} . $App::CONFIG{ TT }->{ postfix }, $v, \$output) 
                    or return view_error( $tt->error );
                return $output;
            }

        ),
    );
    
    sub view_error {
        my ( $error ) = shift;
        warn $error;
        return "<pre>" . $error . "</pre>\n";   # really need to HTML encode $error here
    }
}

1;

And here are the templates….

layout.tt


<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
   "http://www.w3.org/TR/html4/strict.dtd">

<html lang="en">
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
	<title>[% site_tit %]</title>
</head>
<body>
[% body %]
</body>
</html>

home.tt


<h1>Hello.. [% tit %]</h1>

<a href="[% R('Page') %]">Have a look here</a>

page.tt


<h1>Hello again... [% tit %]</h1>

<p>$v->{list}...</p>

<ul>
    [% FOREACH item IN list %]
    <li>[% item %]</li>
    [% END %]
</ul>

<a href="[% R('Home') %]">back to home</a>

Stash variables in Squatting (ie. variables that can used between controller & the view/template) can be set/get by $self->v
NB. “v” is for variables and shouldn’t be confused in anyway with “view” ;-(

Using “layout[.tt]” method/template is optional in Squatting (and Camping) so u can drop this and it will just render the view/template only. The code uses “layout” thus home.tt & page.tt renders as [% body %] via layout.tt

R() returns the route used by the specified controller ( for eg. R(‘Page’) returns “/path/to/page” ). This is quite a handy subroutine to export to TT templates!

So see it working just name above program “App.pm” and put in same directory as the template files and just do squatting App and then point your browser to http://localhost:4234/

Hopefully more on Squatting soon. So if u fancy a bit of fun web programming then give Squatting a go!


]]> http://transfixedbutnotdead.com/2008/10/21/using-template-toolkit-with-squatting/feed/ 3 draegtun http://transfixedbutnotdead.com/2008/03/14/doodling-with-moose-intermission/ http://transfixedbutnotdead.com/2008/03/14/doodling-with-moose-intermission/#comments Fri, 14 Mar 2008 10:40:31 +0000 draegtun http://draegtun.wordpress.com/?p=25 ]]> Gosh… don’t recall WordPress munging up my code before (when using <pre> or <code>)? As soon has I tried to edit the content online it got garbled up and became messy. So as long has u don’t edit it then its fine. It’s probably why I normally do the content offline and then post it! (however I’ve had problems with that also… thats for another post!)

Anyway I wanted tart up the code and noticed that WordPress blogs comes with syntaxhighlighter Goodle Code project….

http://faq.wordpress.com/2007/09/03/how-do-i-post-source-code/

Certainly looked good but didn’t come with a Perl option ;-( (big oversight… and it appears someone as posted the necessary “data” to the project but code simply hasn’t been included!)

Anyway I used Ruby as syntax language for the Perl code and it works pretty well (no surprises!). However it didn’t format long lines correctly so had to manually put in some newlines/tabs into the code to make it look good (hence extra lines).


]]> http://transfixedbutnotdead.com/2008/03/14/doodling-with-moose-intermission/feed/ 0 draegtun