Fast forward to today. I'm a professional "programmer"... but most of my colleagues have no interest in sharing code and discussing it. (At the last place I worked, the other guys would roll their eyes at any request I would make for design meetings or brief "show and tell" type exchanges.) Maybe it's different in your area of expertise, but the general attitude appears to be that folks want to just be left alone to do things their own way. In some cases, I doubt that we even a common framework or language from which to discuss good design principles.... (I'm sure Alan Kay has noticed something like this and maybe even cited it as evidence that we're still in the dark ages of programming....)

Similarly, I remember an art teacher I had. I asked him how to get good at drawing. He said everyone has a million bad drawings in them and that the sooner you get those out of the way, the more likely you are to get good. Learning a new programming language is like that, except... I guess it's more like you have to get 100 bad short programs out of the way... and then you have to get at least 10 medium sized programs out of the way.

So here I am learning Perl in general and Moose in particular. Definitely "new to the area" in that department! Also, I have below my second "bad" medium sized program for this platform. There are a lot of directions I can go with this stuff, but I'd like to tune things up some more before I get too deep into anything else. Please feel free to jump in with your comments if you're into it. Here are a few random notes:

* Installing Moose on cygwin didn't work for me. I tried a few different ways, but always got hung up on the dependencies.

* Installing Moose on Windows was pretty painless. Whatever the package manager was that I used, it worked great.

* The default shell for Emacs on Windows is pretty retarded. The whole concept of STDIN seems gone there.... Argh....

* You can't seem to cut and paste text from a standard Windows console window. Argh.

* In the code below, I haven't completely refactored the Parser to be completely "Moose-ish". I did factor out a Table object, though.

* There are a few instances of cut & paste code repetition below.

* The program attempts to implement a strict by-the-book character generation sequence for Classic Traveller. I used the revised rules from The Traveller Book. (All classic Traveller materials are available on CD-Rom from FFE. Mongoose has recently released a new version of the game. e23 and Comstar both have pdf products available. I'm partial to the original stuff, myself.) There are other character generation programs floating around, but I'm not sure how well they tend to follow the rules as written.

* The current design is mostly data-driven. Someone that knows Traveller should be able to customize the program to some extent without knowing Perl. I would like to extend the capabilities of the configuration language so that ordinary joes can hack things into whatever houserules they've cooked up. My concept for this would be something halfway between 8-bit BASIC and a spreadsheet... but slightly OOPish, maybe. Maybe I should write a compiler to convert the script file into standard Perl? I dunno.... We'll see where this goes....

* After cleaning up the program as it stands, I should be in a position to code up other chargen schemes (as my spare time allows)... and I should have an opportunity to use more of Moose's features then. Going forward (assuming I go forward) I would want to strike some sort of balance between improving the generic parser tool and adding more scope and comprehensiveness to the generator. I wouldn't want to have a perfect parser that isn't implementing anything... and I wouldn't want my code to turn to sludge and then collapse under the weight of its own scope, either. At some point, I do want the hypothetical "power user" to be able to make this work however they want, though.

[sourcecode language='ruby']
#!\usr\bin\perl
package Routines;

# get random number from 0 to n-1 using rand function
sub get_rand { int (rand $_[0]); }

sub d_six { return get_rand(6) + 1; }

sub two_d_six { return d_six() + d_six(); }

# TODO: This routine should omit I and O results to be real 'Traveller extended-hex' values
sub tr_hex {
my $num = shift;
return 0 if $num <= 0;
return $num if $num <= 9;
die "$num is greater than 36-- too big for 'hex' conversion" if $num > 36;
return chr($num + 64 - 9);
}

###################################################################################################

package Callback;
use Moose;

sub process {
print "Hello World!\n";
}

sub choose {
my ($self, $text) = @_;
my @options = split /;/, $text;
#print "the text is $text\n";
my $i = 0;
print "\n";
foreach(@options){
$i++;
print "$i: $_\n";
}

my $answer;
until ($answer) {
print ">> ";
chomp(my $line = );
if ($line =~ /^\d+$/) {
$answer = $options[$line - 1];
} else {
foreach(@options){
if(/^$line/i){
$answer = $_;
last;
}
}
}
}
return $answer;
}

###################################################################################################

package Table;
use Moose;

my $show_debug2 = 0;

has Name => (is => 'rw', isa => 'Str', default => 'Bob');
has 'Rows' => (isa => 'HashRef', is => 'rw', default => sub { my %hash; return \%hash; } );
has 'Columns' => (isa => 'ArrayRef[Str]', is => 'rw', default => sub { my @a; return \@a; } );
has 'ColumnRegexes' => (isa => 'ArrayRef[Str]', is => 'rw', default => sub { my @a; return \@a; } );

sub initialize {
my ($self, $table, $text) = @_;
$self->Name($table);
my ($columns, $column_regexes) = parse_column_header($text);
$self->Columns($columns);
$self->ColumnRegexes($column_regexes);
my %rows;
$self->Rows(\%rows);
}

sub load_line {
my ($self, $text) = @_;
my ($rowkey, $row) = parse_row_detail($self->Name(), $text, $self->Columns());
$self->Rows->{$rowkey} = $row;
}

sub cell {
my ($self, $row, $column) = @_;
return $self->Rows->{$row}->{$column};
}

### pass a comma delimited header line from a table definition
### and get two array references describing the table structure
sub parse_column_header {
my ($line) = @_;
my @fields = split /,/, $line;
my $column_number = 0;
my @columns;
my @regexes;
print "reading columns to table: $line\n" if $show_debug2;
foreach(@fields){
my $field = $_;
$field =~ s/^\s+|\s+$//g; # trim field
if($field =~ /^([^\/]*)\/([^\/]*)\//){
$field = $1;
$regexes[$column_number] = $2;
}
$columns[$column_number] = $field;
$column_number++;
}
return (\@columns, \@regexes);
}

### pass a table name and a comma delimited header line from a table definition
### and also pass a reference to an array of column names...
### and get the row's key and a hash of detail data
sub parse_row_detail {
my ($table, $line, $columns) = @_;
my @fields = split /,/, $line;
print "reading rows to table $table: $line\n" if $show_debug2;
my %row;
my $column_number = 0;
my $rowkey;
my $didit;
foreach(@fields){
my $field = $_;
$field =~ s/^\s+|\s+$//g; # trim field
# Need to allow some keys to be '0'!
if ($didit){
$row{$columns->[$column_number]} = $field;
} else {
$rowkey = $field;
}
$column_number++;
$didit = 1;
}
return ($rowkey, \%row);
}

sub show_keys {
my ($self) = @_;
my $key;
my $table = $self->Name();
my $rs = $self->Rows();
foreach $key (sort keys %{$rs}){
print "$table row : $key\n";
}
my $cs = $self->Columns();
foreach (@{$cs}){
print "$table column : $_\n";
}
}

###################################################################################################

package Parser;
use Moose;

has 'Tables' => (isa => 'HashRef[Table]', is => 'rw', default => sub { my %hash; return \%hash; } );
has ReadAsTable => (isa => 'HashRef[Table]', is => 'rw', default => sub { my %hash; return \%hash; } );

my $read_type = 0;
my $current_table = "None";
my %widgets;
my $current_widget = "None";
my $widget_parser_sub = \&reading_widget_fields;
my $show_debug = 0;

my $lame_hack;

sub lameness {
my $self = shift;
$lame_hack = $self;
}

sub cell {
my ($self, $table, $key, $column) = @_;
return $self->Tables->{$table}->cell($key, $column);
}

sub show_keys {
my ($self, $table) = @_;
if ($table){
$self->Tables()->{$table}->show_keys();
} else {
foreach my $key (sort keys %{$self->Tables()}){
print "Table: $key\n";
}
}
}

### why can't I call my properties without $self?
sub reading_table_header {
my ($line) = @_;
my $T = new Table();
$T->initialize($current_table, $line);
$lame_hack->Tables()->{$current_table} = $T;
$read_type = 2;
}

sub reading_table_detail {
my ($line) = @_;
my $T = $lame_hack->Tables()->{$current_table};
$T->load_line($line);
}

my %dispatch_data = (

'^Table ([A-Za-z]+):' => {
code => sub { $current_table = $1; $read_type = 1 },
debug => sub { print "(reading table $1)\n" },
},

'^\#(.*)' => {
code => {},
debug => sub { print "found a comment: $1\n" },
},

'^[\w]*$' => {
code => sub { $read_type = 0 },
debug => sub { print "(Whitespace line)\n" },
},

'^ReadCell "([^"]+)" As "([^"]+)"' => {
code => sub { $lame_hack->ReadAsTable->{$1} = $2; },
debug => sub { print "(Whitespace line)\n" },
},

);

# build the dispatch table-- but only for regex's with code or debug routines
### (thanks to draegtun again)
my $dispatch_table = {};
while ( my ( $regex, $dispatch ) = each %dispatch_data ) {
$dispatch_table->{ $regex } = sub {
$dispatch->{ code }->() if exists $dispatch->{ code };
$dispatch->{ debug }->() if $show_debug;
} if exists $dispatch->{ code } or ($show_debug and exists $dispatch->{ debug });
}

my $alternate_dispatch_table =
{ 1 => \&reading_table_header,
2 => \&reading_table_detail,
};

sub parse {
my $self = shift;
my ($file) = @_;
#print "You are trying to open $file.\n";
open SCRIPT, "< $file";
while (