Simple Ways
To Be A
Better Programmer
Michael G Schwern
schwern@pobox.com

Discussion Session
D135 @ 5:30pm

#!/usr/bin/perl -s
$;=$/;seek+DATA,!++$/,!$s;$_=<DATA>;$s&&print||$g&&do{$y=($x||=20)*($y||8);sub
i{sleep&f}sub'p{print$;x$=,join$;,$b=~/.{$x}/g}$j=$j;sub'f{pop}sub
n{substr($b,&f%$y,3)=~tr,O,O,}sub'g{$f=&f-1;($w,$w,substr($b,&f,1),O)[n($f-$x)+
n($x+$f)-(substr($b,&f,1)eq+O)+n$f]||$w}$w=\"\\40\";$b=join'',@ARGV?<>:$_,$w
x$y;$b=~s).)$&=~/\\w/?O:$w)ge;substr($b,$y)=q++;$g='$i=0;$i?$b:$c=$b;
substr+$c,$i,1,g$i;$g=~s?\\d+?($&+1)%$y?e;$i-$y+1?eval$g:do{$i=-1;$b=$c;p;i
1}';sub'e{eval$g;&e}e}||eval||die+No.$;
__DATA__
if($j){{$^W=$|;*_=sub{$=+s=#([A-z])(.*)#=#$+$1#=g}}
@s=(q[$_=sprintf+pop@s,@s],q[
if($j){{$^W=$|;*_=sub{$=+s=#([A-z])(.*)#=#$+$1#=g}} #_The_Perl_Journal_#
@s=(q[%s],q[%s])x2;%s;print\"\\n\"x&_,$_;i$j;eval}
])x2;$_=sprintf+pop@s,@s;print\"\\n\"x&_,$_;i$j;eval}$/=$y;$\"=\",\";print
q<#!/usr/local/bin/perl -sw
if(!$s){>.($_=<>).q<}else{@s=(q[printf+pop@s,@s],q[#!/usr/local/bin/perl -sw
if(!$s){>.(s$%$%%$g,tr=[=[===tr=]=]=||&d,$_).q<}else{@s=(q[%s],q[%s])x2;%s}
])x2;printf+pop@s,@s}
>

Beyond syntax

Tools for the
toolbox

Easy To Do

Hard To Screw Up

Independent

You can do them
alone

Computer Science
+
People
=
Software Development

Why learn?

Cross-training is
sexay

know

Don’t know

Don’t know you
don’t know

“I don’t know”

“Tell me about it”

Why

New things
mean failure

New versions

Hang out with
other folks who
learn

Join the
community

Broadcast your
problem

Go be stupid

Learn a really
different
language

Look it up
yourself

Wikipedia

Relevant blogs

Tech-specific
search sites

> Thank you for your note. Opera is
> not a supported browser.

Why not? I see absolutely no reason to
exclude Opera from the list of
supported browsers.
When I tell Opera to ID as Firefox, it
works as expected. No patches needed.
So please get back in sync with the
real world and also enable Opera.

Topic for #eve is: Corp meeting on Vent: Saturday 14th and 21st
at 16:00 EVE time. All hands on deck! :-)

<wibble> Announcing \"all hands on deck\" without announcing *why* is not
useful.
<wibble> I get enough shit from work, I certainly don't need any more
from a corp on Eve.
<wibble> just irritated at people telling me what I *have* to do.

On Wed, May 09, 2007 at 08:34:52PM -0700, Michael G Schwern wrote:
> I'm sorry, but that's the automated failure report from CPAN::Reporter.
> I was doing an automated install.

What can I do to force automated junk mailers
to follow my policy of bug reports?

Speak with the CPAN::Reporter folks about what you would like to see in the
failed install report. Perhaps they can add in the Makefile.PL and make
output to the automatic report. This would be helpful, especially for
complicated builds like yours. Perhaps you could change your test
files so they automatically output the diagnostics you want on failure rather
than rely on the user to sift through the INSTALL docs to find the special
instructions

“You’re right”

someone screwed up the plan in
one of Encode's tests.

+1
0
-1

Bitching
is not
doing

Means

Ends

Be Available

Design <-> Code

Interface -> User

Get it out of
your head

Documentation

Wiki

Tickets

How are you?

Having fun?

Feel ok?

Fear-based Programming

Fear of change

Fear of bugs

Fear of getting fired

Small Chunks

Testing

Test first

Test during

Test automaticly

Stay at 100%

Effective
Version
Control

Code

Test

Commit

How much?

One Thing

One Source Of Breakage

----------------------------------------------------------------------
r32185: schwern | 2007-06-29 18:22:55 -0700
Need a blank line preceeding POD directives.
----------------------------------------------------------------------
=== local/Test-Simple/lib/Test/Builder.pm
==================================================================
--- local/Test-Simple/lib/Test/Builder.pm (revision 32184)
+++ local/Test-Simple/lib/Test/Builder.pm (revision 32185)
@@ -983,6 +983,7 @@
# I'm not ready to publish this. It doesn't deal with array return
# values from the code or context.
+
=begin private
=item B<_try>

----------------------------------------------------------------------
r27706: schwern | 2007-03-16 15:19:55 -0700
Add a test to ensure an object can lie about being an IO::Handle.
----------------------------------------------------------------------
=== local/Test-Simple/t/is_fh.t
==================================================================
--- local/Test-Simple/t/is_fh.t (revision 27705)
+++ local/Test-Simple/t/is_fh.t (revision 27706)
@@ -11,7 +11,7 @@
}
use strict;
-use Test::More tests => 10;
+use Test::More tests => 11;
use TieOut;
ok( !Test::Builder->is_fh(\"foo\"), 'string is not a filehandle' );
@@ -34,3 +34,15 @@
unless defined *OUT{IO};
ok( Test::Builder->is_fh(*OUT{IO}) );
}
+
+
+package Lying::isa;
+
+sub isa {
+ my $self = shift;
+ my $parent = shift;
+
+ return 1 if $parent eq 'IO::Handle';
+}
+
+::ok( Test::Builder->is_fh(bless {}, \"Lying::isa\"));

----------------------------------------------------------------------
r27705: schwern | 2007-03-16 15:10:39 -0700
Comment about the nature of the filehandle in is_fh() was backwards.
----------------------------------------------------------------------
=== local/Test-Simple/lib/Test/Builder.pm
==================================================================
--- local/Test-Simple/lib/Test/Builder.pm (revision 27704)
+++ local/Test-Simple/lib/Test/Builder.pm (revision 27705)
@@ -1025,8 +1025,8 @@
my $maybe_fh = shift;
return 0 unless defined $maybe_fh;
- return 1 if ref $maybe_fh eq 'GLOB'; # its a glob
- return 1 if ref \\$maybe_fh eq 'GLOB'; # its a glob ref
+ return 1 if ref $maybe_fh eq 'GLOB'; # its a glob ref
+ return 1 if ref \\$maybe_fh eq 'GLOB'; # its a glob
return eval { $maybe_fh->isa(\"IO::Handle\") } ||
# 5.5.4's tied() and can() doesn't like getting undef

----------------------------------------------------------------------
r26467: schwern | 2006-12-24 12:36:01 -0800
Typo
----------------------------------------------------------------------
=== local/Test-Simple/Changes
==================================================================
--- local/Test-Simple/Changes (revision 26466)
+++ local/Test-Simple/Changes (revision 26467)
@@ -1,5 +1,5 @@
0.66 Sun Dec 3 15:25:45 PST 2006
- - Restore 5.4.5 compatibility (unobe@cpan.org) [rt.cpanorg 20513]
+ - Restore 5.4.5 compatibility (unobe@cpan.org) [rt.cpan.org 20513]
0.65 Fri Nov 10 10:26:51 CST 2006

----------------------------------------------------------------------
r17879: schwern | 2006-09-04 01:15:12 -0700
* Made most of the error messages report in the caller's context.
[rt.cpan.org #20639]
----------------------------------------------------------------------
=== local/Test-Simple/lib/Test/Builder.pm
==================================================================
--- local/Test-Simple/lib/Test/Builder.pm (revision 17878)
+++ local/Test-Simple/lib/Test/Builder.pm (revision 17879)
@@ -35,7 +35,7 @@
$$data = ${$_[0]};
}
else {
- die \"Unknown type: \".$type;
+ die(\"Unknown type: \".$type);
}
$_[0] = &threads::shared::share($_[0]);
@@ -50,7 +50,7 @@
${$_[0]} = $$data;
}
else {
- die \"Unknown type: \".$type;
+ die(\"Unknown type: \".$type);
}
return $_[0];
@@ -247,8 +247,7 @@
return unless $cmd;
if( $self->{Have_Plan} ) {
- die sprintf \"You tried to plan twice! Second plan at %s line %d\\n\",
- ($self->caller)[1,2];
+ $self->croak(\"You tried to plan twice\");
}
...

Task branches

BDUF

Refactoring

JIT Design

Rename

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $arg = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$arg\">/;
}
if ( my $arg = delete $parms{format} ) {
if ($arg eq 'text') {
require HTML::TreeBuilder;
my $tree = HTML::TreeBuilder->new();
$tree->parse($content);
$tree->eof();
$tree->elementify(); # just for safety
$content = $tree->as_text();
$tree->delete;
}
else {
$self->die( qq{Unknown \"format\" parameter \"$arg\"} );
}
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $arg = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$arg\">/;
}
if ( my $arg = delete $parms{format} ) {
if ($arg eq 'text') {
require HTML::TreeBuilder;
my $tree = HTML::TreeBuilder->new();
$tree->parse($content);
$tree->eof();
$tree->elementify(); # just for safety
$content = $tree->as_text();
$tree->delete;
}
else {
$self->die( qq{Unknown \"format\" parameter \"$arg\"} );
}
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
if ($format eq 'text') {
require HTML::TreeBuilder;
my $tree = HTML::TreeBuilder->new();
$tree->parse($content);
$tree->eof();
$tree->elementify(); # just for safety
$content = $tree->as_text();
$tree->delete;
}
else {
$self->die( qq{Unknown \"format\" parameter \"$format\"} );
}
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

Extract

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
if ($format eq 'text') {
require HTML::TreeBuilder;
my $tree = HTML::TreeBuilder->new();
$tree->parse($content);
$tree->eof();
$tree->elementify(); # just for safety
$content = $tree->as_text();
$tree->delete;
}
else {
$self->die( qq{Unknown \"format\" parameter \"$format\"} );
}
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
if ($format eq 'text') {
require HTML::TreeBuilder;
my $tree = HTML::TreeBuilder->new();
$tree->parse($content);
$tree->eof();
$tree->elementify(); # just for safety
$content = $tree->as_text();
$tree->delete;
}
else {
$self->die( qq{Unknown \"format\" parameter \"$format\"} );
}
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

if ( my $format = delete $parms{format} ) {
if ($format eq 'text') {
require HTML::TreeBuilder;
my $tree = HTML::TreeBuilder->new();
$tree->parse($content);
$tree->eof();
$tree->elementify(); # just for safety
$content = $tree->as_text();
$tree->delete;
}
else {
$self->die( qq{Unknown \"format\" parameter \"$format\"} );
}
}

if ( my $format = delete $parms{format} ) {
if ($format eq 'text') {
require HTML::TreeBuilder;
my $tree = HTML::TreeBuilder->new();
$tree->parse($content);
$tree->eof();
$tree->elementify(); # just for safety
$content = $tree->as_text();
$tree->delete;
}
else {
$self->die( qq{Unknown \"format\" parameter \"$format\"} );
}
}

method _content_as_text ($content) {
require HTML::TreeBuilder;
my $tree = HTML::TreeBuilder->new();
$tree->parse($content);
$tree->eof();
$tree->elementify(); # just for safety
my $formatted_content = $tree->as_text();
$tree->delete;
return $formatted_content;
}

if ( my $format = delete $parms{format} ) {
if ($format eq 'text') {
$content = $self->_content_as_text($content);
}
else {
$self->die( qq{Unknown \"format\" parameter \"$format\"} );
}
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
if ($format eq 'text') {
require HTML::TreeBuilder;
my $tree = HTML::TreeBuilder->new();
$tree->parse($content);
$tree->eof();
$tree->elementify(); # just for safety
$content = $tree->as_text();
$tree->delete;
}
else {
$self->die( qq{Unknown \"format\" parameter \"$format\"} );
}
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
if ($format eq 'text') {
$content = $self->_content_as_text($content);
}
else {
$self->die( qq{Unknown \"format\" parameter \"$format\"} );
}
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
if ($format eq 'text') {
$content = $self->_content_as_text($content);
}
else {
$self->die( qq{Unknown \"format\" parameter \"$format\"} );
}
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

method _format_content ($format, $content) {
if ($format eq 'text') {
return $self->_content_as_text($content);
}
else {
$self->die( qq{Unknown \"format\" parameter \"$format\"} );
}
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
if ($format eq 'text') {
$content = $self->_content_as_text($content);
}
else {
$self->die( qq{Unknown \"format\" parameter \"$format\"} );
}
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
$content = $self->_format_content($format, $content);
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
$content = $self->_format_content($format, $content);
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

method _check_unhandled_parms (%parms) {
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
$content = $self->_format_content($format, $content);
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
$content = $self->_format_content($format, $content);
}
$self->_check_unhandled_parms(%parms);
} # is HTML
return $content;
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
$content = $self->_format_content($format, $content);
}
$self->_check_unhandled_parms(%parms);
} # is HTML
return $content;
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
$content = $self->_format_content($format, $content);
}
$self->_check_unhandled_parms(%parms);
}
return $content;
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
if ($format eq 'text') {
require HTML::TreeBuilder;
my $tree = HTML::TreeBuilder->new();
$tree->parse($content);
$tree->eof();
$tree->elementify(); # just for safety
$content = $tree->as_text();
$tree->delete;
}
else {
$self->die( qq{Unknown \"format\" parameter \"$format\"} );
}
}
for my $cmd ( sort keys %parms ) {
$self->die( qq{Unknown named argument \"$cmd\"} );
}
} # is HTML
return $content;
}

method content () {
my $content = $self->{content};
if ( $self->is_html ) {
my %parms = @_;
if ( exists $parms{base_href} ) {
my $base_href = (delete $parms{base_href}) || $self->base;
$content =~ s/<head>/<head>\\n<base href=\"$base_href\">/;
}
if ( my $format = delete $parms{format} ) {
$content = $self->_format_content($format, $content);
}
$self->_check_unhandled_parms(%parms);
}
return $content;
}

Revealing Reuse

refactoring.com

Simplest Thing

Optimizing

Rule #1

Rule #1: Don’t!

Complicates

Wastes Time

Rule #2

Rule #2: Don’t do it yet!

Does it work?

Is it tested?

Is it documented?

How fast?

Throw Hardware

Rule #3

Rule #3: Profile First!

Rule #4

Rule #4: Better Algorithm

Rule #5

Estimating

Feedback

Mini Milestones

• Get account activated
• Make simple test purchase
• Handle invalid expiration date
• Handle invalid address
• Record transactions
• Associate item with purchase
• Simple user form

Quatloos

Get Out Of
Technical Debt
NOW!

Form

Functionality

Separate

People

Small Chunky Pieces

Thank You

Gabrielle

Candy

Selena

Keith

Everyone I pestered

Discussion Session
D135 @ 5:30pm