Two Alpha

Just Kids: A story of two young people becoming Artists

2010-10-06T08:36:00.001-07:00

Patti Smith's recent book "Just Kids" is a wonderfully told story of two young people (Smith and Robert Mapplethorpe) pursuing their dreams and becoming Artists. The story is told in Smith's customary tender fierceness - qualities which we can absorb and future in ourselves as we read along. I highly recommend this book to anyone interested in artistic processes.

Just Kids on Amazon

Technorati Tags: art, artist

RPC - How can you be two places at once when you're not anywhere at all?

2010-03-06T07:49:00.000-08:00

Recently I've been looking into using either XML-RPC or JSON-RPC to communicate between a Cocoa client and a PHP back-end.

I came across Samuel Sutch's Objective-C implementation of JSON-RPC and saw what to me is a curious pattern: methods with no name that take any object (id) as an argument and return an object of indeterminate type (id)

- (id):(id)arg {
// do stuff
}

While this is legal in Objective-C it sure is difficult for me to follow. That said, I'm not an expert in ObjC so I consider this a learning opportunity.

I suspect that the reasoning behind this has something to do with the fact that the author is implementing a version of the "Deferred" pattern. Still, it seems like code that is very hard to maintain. I'm hoping to get in touch with the author and learn more. At a minimum I hope to become better educated.

Technorati Tags: Mac OS X, Objective-C, open source, software development

Apple Professional Apps Documentation Goes on the Web

2009-07-23T16:35:00.001-07:00

The complete documentation for Apple's professional apps is now available on the web.
Links to the individual products are:

Josh Keppel reviews some Oakland California Burning Man cultural spin-offs

2009-07-18T13:02:00.001-07:00

Flamethrower SHooting Gallery crew member Josh Keppel is also a writer for NBC Bay Area - a San Francisco Bay Area local news and events web site. Josh recently wrote a review of some Oakland-based hot-cultire events. Have a look.

Why Technical Debt Should Be More Visible

2009-02-28T09:49:00.001-08:00

Recently my colleague Jeffrey Thalhammer of Imaginative Software sent me a pointer to Steve McConnell's article on Technical Debt: http://blogs.construx.com/blogs/stevemcc/archive/2007/11/01/technical-debt-2.aspx

Instead of sending Jeff an email with all my notes, I'm sending him a pointer to this posting.

Overall I thought the article plus the comments were very good. The comments and back-and-forth really add a lot of value the the article and I suggest anyone reading the article make their way all the way through the comments.

I think we should write a version of this aimed entirely at non-technical people.

McConnell does acknowledge that estimating the "interest payments" is very difficult. One of the (maybe not so obvious?) reasons is that involves calculating the expected lifetime of the system, because as the article says:

When a system is retired, all of the system's technical debt is retired with it. Once a system has been taken out of production, there's no difference between a "clean and correct" solution and a "quick and dirty" solution.

So having a realistic estimate of the expected lifetime of the system make a huge difference it the expected cost of the debt.

I also like the attention that the article and comments gave to the issue of why different people may have different attitudes towards technical debt. For example, the article says:

The reason most often cited by technical staff for avoiding debt altogether is the challenge of communicating the existence of technical debt to business staff and the challenge of helping business staff remember the implications of the technical debt that has previously been incurred.

and commenter Robin Barooah said:

This might further explain why business people are prepared to accept technical debt - they aren't the ones who are going to have to pay it off. The developers suffer real consequences because they aren't learning or growing by having to rework code that they knew was being done to substandard quality in the first place.

I think Barooah's comment is spot-on and indicates an often unarticulated and under appreciated difference between financial and technical debt.

The article summarizes some of this by saying that:

The main issue seems to be that, unlike financial debt, technical debt is much less visible, and so people have an easier time ignoring it.

I would amend that to say "so some people have" cf. Barooah's comment above, but I basically agree: making the "technical debt" more visible is fundamental to improving how it is handled. That means means finding ways to make it visible to people with different perspectives: Finding indicators that are equally meaningful to both business and technical staff would be a big help.

Technorati Tags: agile, estimating, programming, software development

http://documentation.apple.com/ launched.

2008-09-29T12:15:00.001-07:00

My team launched a website with all the documentation for Final Cut Server this past Monday.

JavaScript Best Practices, or "JavaScript: The Good Parts"

2008-09-23T08:44:00.000-07:00

The book, "JavaScript: The Good Parts" will be useful to both beginners and experienced JavaScript programmers who want to create better JavaScript code.

"JavaScript: The Good Parts" is a slim volume (153 pages) that clearly explains a number of best practices for JavaScript giving the "why" and the "how" for dozens of issues such as creating objects, using JSON securely, dealing with regular expressions, checking your code using JSLint, and avoiding "attractive nuisances" such as "implied globals." I only wish the author had included something on setting up unit-test frameworks for JavaScript (see for example, Scriptaculous.)

JavaScript is a programming language growing in importance every day - increasingly complex systems such as GMail, Google Maps, and MobileMe depend heavily upon it.
The guy who wrote this book, Douglas Crockford, is a "senior JavaScript architect at Yahoo!" and is the fellow who introduced JavaScript Object Notation (JSON) and created JSLint, a JavaScript style-checker (static code analyzer.)

"JavaScript: The Good Parts" (Douglas Crockford)

See also:

"Perl Best Practices" (Damian Conway)

Technorati Tags: javascript, software, software development, static analysis

Flamethrower Shooting Gallery Most Dangerous Interactive Installation on the Playa

2008-09-04T20:35:00.001-07:00

The Flamethrower Shooting Gallery was a big success at Burning Man 2008.

I asked DaveX (head of fire safety for the Burning Man organization) for his view and Dave said:

"... heard nothing but good things about how you guys ran it, and I think it's the most dangerous thing out there."

Thanks Dave!

The Flamethrower Shooting Gallery was the only installation on the playa that combined horizontal flame effects with liquid fuel and was controlled by participants. The fire safety team measured the facial skin temperature on shooters at 130 degrees Fahrenheit while the flamethrowers were in action.

This photo shows some shooters getting ready to fire with the assistance of the Range Safety Officers.

Technorati Tags: Flamethrower Shooting Gallery

Flamethrower Shooting Gallery listed on Laughing Squid

2008-07-16T22:22:00.001-07:00

A little alternative press coverage at Laughing Squid. Also, here's a bit of television news coverage of the Fire Arts Festival, at The Crucible where the Flamethrower Shooting Gallery had its world premiere.

Herb Meyer World Economic Forum Paper could be a Fake

2008-06-22T10:55:00.000-07:00

Did Herb Meyer really write and/or present the paper attributed to him as having been presented at the World Economic Forum in Davos, Switzerland?

There are a lot of copies of this paper on the web - variously titled "Four major transformations of the New Century", "A global intelligence briefing for CEOs", etc.

The web site of the World Economic Forum does not seem to contain Herb Meyer's name at all, and certainly not in the their list of contributers as of late June 2008.

Technorati Tags: economics, politics, puppy

Modern Web MVC Frameworks

2008-05-26T10:05:00.000-07:00

It's now mid-2008, and there are a fair number of open source web application frameworks that use the Model-View-Controller approach. They all provide built-in support for automated testing.

Here is an (incomplete) list of widely used frameworks:

Groovy

Java

Perl

PHP

Python

Ruby

Technorati Tags: open source, MVC, unit tests

Releasing software under an Open Source License to Increase Business Value

2008-02-17T22:49:00.001-08:00

Releasing software under an Open Source License can increase the business value of that software.

Why License as Open Source?
As a developer when I create software and license it to a customer there are a number of reasons why I might want that license to be an Open Source license. That is, that are a number of ways in which Open Source licenses increase the value of the software to me, the original author. This value points should be weighed against the value created by Closed Source licenses.

Open Source Need Not Equal "Free of Charge"
Software can be Open Source and fee-for-use and it can be closed-source but free-of-charge.

Examples:

Embedding the MySQL database in your product: It is Open Source, but you must pay for the right to embed MySQL in your product.
Microsofts' Internet Explorer web browser is free-of-charge but is Closed Source.

Releasing software under an Open Source license does not automatically mean you are allowing all use to be free of charge. Indeed, crafting good Open Source fee-for-use licenses is an area of law which would benefit from more creative efforts.

Value From Increased Networking Utility
Many of the value propositions listed below derive from the idea of increasing the human networking utility of my software - that is, as under an Open Source license my software can be used to help create and maintain my connections to other people: developers, potential clients, collaborators, pundits, marketers, etc. and a great deal (maybe most?) of the business value available ("Total Value Available") is obtained through connections and relationships, so anything that promotes good connections to other people has potential business value which should be considered.

Closed Source software licenses act in some ways as barriers to creating and maintaining connections to people. Healthy relationships require boundaries, so this is not a question of all-or-nothing but rather one of degree and kind. A lot of what a Closed Source license does is to try and prevent a loss of value, as opposed to providing utility that can lead to an increase in value.

The value that a Closed Source license seeks to create or preserve is based on scarcity and secrecy. The Closed Source License seeks to create a barrier to understanding how the software works, and making it harder for others to reuse or modify the software. The Closed Source License is addressing the creators' fears that if someone can read the source code they will have an easier time creating a competing product, that it will be easy to copy portions of the code and reuse it without payment and that t will be hard to detect such violations. These are real issues and should be considered before releasing source code in any form.

Specific Kinds of Value Created or Increased by an Open Source License
Using an Open Source License for software I create increases its value to me by:

Ensuring that I have the right to re-use the software for another project/client.
Increasing the likelihood that my software will be widely used, and thus I will be known to a wider market, and possibly gain market-share and "mind-share."
Increasing the likelihood that my software will be improved. I gain by being associated with the higher-quality experiences the users have, even though some improvements are made by others, as the original author, some of the goodness rubs off on me.
Making it easier to use my software as a marketing tool - I can show the code to prospective clients and collaborators and partners. Increasing the human-networking utility of my software is a
Making it easier to incorporate other Open Source Software into my product, thus giving me a much wider range of options for adding features and making improvements, so I can respond to change requests and new opportunities much faster than if any change had to be implemented de novo.
Providing an effective avenue for the widest possible expert review of the softwares' security. For example, Open Source software that handles vote counting will likely inspire higher confidence and thus have a greater value.

Some Ideas For Open Source Licenses
What can/should one put in a License that is part of a Software Development Contract? I am thinking here of things that specifically relate to adding value for the licensor, for example:

Non-exclusivity. Licensor can use the software for other projects.
Licensor has the right to list the Licensee in marketing materials (e.g. a web site) as a Licensee of the Software.
Prescribing a mechanism for Licensee to "post-back" changes to the software.

There are probably a lot more things to consider along these lines - how releasing software as Open Source can increase the softwares' value to the releasor.

SEE ALSO

Some widely used Open Source Licenses:

Technorati Tags: marketing, open source, software development

Markets are not mathematical creatures.

2008-02-07T06:50:00.001-08:00

Stock markets look like mathematical phenomena, but they are not. Stock markets are psychological phenomena.

See "Demon of our own Design."

BuildBot: Continuous Integration System

2007-12-29T01:27:00.001-08:00

I've spent some of this holiday season learning how to set up BuildBot (http://buildbot.net/) which is a Continuous Integration system that is especially aimed at open-source style projects: You set up a central "build master", and one or more "build slaves" - and it is very easy for someone to set up a new build slave, so if you have some new platform you want to test a project on you can add a build slave. The build-master admin has to add your slave on the master side, and the slave needs to be able to access the source code repository (CVS in my case.)

I've got three of my Perl projects from my CVS repo running under BuildBot now, and it's all working, except email notification of build status - no email is getting to the mail server, and i have yet to learn how to debug that.

When I commit a change to my CVS repository for one of these projects that kicks off a build on one or more build slaves, which checks out the latest code, and runs all the unit tests. The build master shows the results in a web page.

I've got about 9.5 hours into it, (out of an initial estimate of 12) include various yak-shaving activities.

For now I have the build status pages for the three projects at:

Perl-Metrics-Simple - Building using both MakeMaker and Module::Build. This distro provides modules for a utility program to count lines, packages, subs and complexity of Perl files.
DBIx-Wrapper-VerySimple - Simplify use of DBI.
Text-TagTemplate - Lightweight flexible template parsing module.

See also my earlier posting with a review of a book on Continuous Integration and a link to a comparison of several CI systems.

2007-12-29 update: Starting to add notes to the Perl-QA Wiki.
2008-01-06 update: The email issue was caused by a typo in my master.cfg file.
subject='%(builder) BUILD STATUS', WRONG
subject='%(builder)s BUILD STATUS', CORRECT
Note the missing 's' after the closing parenthesis - it is part of a Python extended printf statement.
Also, I have now added a fourth buildmaster which builds the Parrot project. All my buildbot configurations are now at: http://www.eigenstate.net/buildbot/masters.html
2008-01-17 update: The open source webkit project uses buildbot - you can see their build status at http://build.webkit.org/

Technorati Tags: continuous integration, software development, software testing

Continuous Integration - Improving Software Quality and Reducing Risk

2007-12-01T16:32:00.001-08:00

Paul Duvall, Steve Matyas, and Andrew Glover have written a fine book describing the value and practice of Continuous Integration or CI for short. If you have heard of CI and want to learn more about it, or if you want to help educate others about it, this book is a very good place to start.

Continuous Integration is a software development practice intended to notify the development team as soon as possible when a defect is introduced. Typically when CI is being used there is an automated system which the builds the entire project many times each day from its source code to its complete form, and all its automated tests and other automated quality assurance tools can be brought to bear.

The authors of "Continuous Integration" repeatedly emphasize the role that CI has in reducing risk in software development and constantly provide examples of specific practices that support and benefit from CI, for example frequent commits to a version control system, automated tests, automated code analysis (test coverage, code complexity, duplication, etc.)

I think this book would be great for a leader that is trying to convince their team or their management of the value of CI, as well as for a team implementing CI for the first time as an aid to deciding what system to choose and what aspects to implement first.

Continuous Integration: Improving Software Quality and Reducing Risk
by Paul Duvall, Steve Matyas, Andrew Glover
Paperback: 336 pages
Publisher: Addison-Wesley Professional (July 9, 2007)
Language: English
ISBN-10: 0321336380
ISBN-13: 978-0321336385

See also:

Codehause.org has a side-by comparison of many Continuous Integration systems.
Perl QA Continuous Integration wiki page.

Technorati Tags: agile, continuous integration, extreme programming, software development, software testing

Time Machine Very Slow on Leopard

2007-11-19T19:26:00.001-08:00

Time Machine will run very slowly if an anti-virus utility such as Norton is scanning each file as it is written or changed on the backup disk.

The fix for this is to go into the Norton Auto-Protect Preference Pane of System Preferences and add your backup disk in the SafeZones tab.

Technorati Tags: Mac OS X

cyradm fails: Can't locate auto/Cyrus/IMAP/imclient_ha.al in @INC

2007-09-08T22:44:00.000-07:00

Attempting to login via cyradm fails because of a missing library.

UPDATE 2007-09-15: I believe I have a fix for this. In Cyrus/IMAP/Shell.pm change line 780 from:

if (Cyrus::IMAP::imclient_havetls()) {

if (Cyrus::IMAP::havetls()) {

See also: https://bugzilla.andrew.cmu.edu/show_bug.cgi?id=2988

Name : cyrus-imapd
Arch : x86_64
Version: 2.3.9
Release: 6.fc6

$ uname -a
Linux galadriel 2.6.22.1-32.fc6 #1 SMP Wed Aug 1 14:30:16 EDT 2007 x86_64
x86_64 x86_64 GNU/Linux
$ cyradm
cyradm> login matisse
Can't locate auto/Cyrus/IMAP/imclient_ha.al in @INC (@INC contains:
/usr/lib64/perl5/site_perl/5.8.8/x86_64-linux-thread-multi
/usr/lib64/perl5/site_perl/5.8.7/x86_64-linux-thread-multi
/usr/lib64/perl5/site_perl/5.8.6/x86_64-linux-thread-multi
/usr/lib64/perl5/site_perl/5.8.5/x86_64-linux-thread-multi
/usr/lib/perl5/site_perl/5.8.8 /usr/lib/perl5/site_perl/5.8.7
/usr/lib/perl5/site_perl/5.8.6 /usr/lib/perl5/site_perl/5.8.5
/usr/lib/perl5/site_perl
/usr/lib64/perl5/vendor_perl/5.8.8/x86_64-linux-thread-multi
/usr/lib64/perl5/vendor_perl/5.8.7/x86_64-linux-thread-multi
/usr/lib64/perl5/vendor_perl/5.8.6/x86_64-linux-thread-multi
/usr/lib64/perl5/vendor_perl/5.8.5/x86_64-linux-thread-multi
/usr/lib/perl5/vendor_perl/5.8.8 /usr/lib/perl5/vendor_perl/5.8.7
/usr/lib/perl5/vendor_perl/5.8.6 /usr/lib/perl5/vendor_perl/5.8.5
/usr/lib/perl5/vendor_perl /usr/lib64/perl5/5.8.8/x86_64-linux-thread-multi
/usr/lib/perl5/5.8.8 .) at
/usr/lib64/perl5/vendor_perl/5.8.8/x86_64-linux-thread-multi/Cyrus/IMAP/Shell.pm
line 780
cyradm>

Evidently I am not the only one getting this problem. See: http://use.perl.org/~jk2addict/journal/32136

Social Dynamics of Pair Programming

2007-05-17T23:16:00.001-07:00

The Social Dynamics of Pair Programming

Interesting paper by Jan Chong and Tom Hurlbutt at Stanford University.

Here's the Abstract:

This paper presents data from a four month ethno-
graphic study of professional pair programmers from
two software development teams. Contrary to the cur-
rent conception of pair programmers, the pairs in this
study did not hew to the separate roles of “driver” and
“navigator”. Instead, the observed programmers
moved together through different phases of the task,
considering and discussing issues at the same strategic
“range” or level of abstraction and in largely the same
role. This form of interaction was reinforced by fre-
quent switches in keyboard control during pairing and
the use of dual keyboards. The distribution of expertise
among the members of a pair had a strong influence on
the tenor of pair programming interaction. Keyboard
control had a consistent secondary effect on decision-
making within the pair. These findings have implica-
tions for software development managers and practi-
tioners as well as for the design of software develop-
ment tools.

(Link to PDF version or Google HTML view)

Technorati Tags: agile, extreme programming, pair programming, XP

Finding which jar file provides a Java class.

2007-05-06T11:23:00.001-07:00

Given a class name such as:

org.springframework.mail.javamail.MimeMessageHelper

www.jarfinder.com provides a fast easy way to find out which .jar file(s) provide the class, with links to the organization and download site for each one.

For example:

http://www.jarfinder.com/?class=org.springframework.mail.javamail.SmartMimeMessage&submit=search

Technorati Tags: java

Estimating Value of a Possible Software Project

2007-04-20T08:54:00.000-07:00

What factors to consider when estimating the value of a possible software project?

I made a list various factors I have considered, more or less formally as the case may be, when estimating the value of undertaking a development project.
When I thought about how I measure these factors I found that I generally think of them as each having a probability-distribution.
Instead of "This feature will cut response time in half", something like "This has a 90% chance of getting of cutting response time by 10%, and maybe a 30% chance of cutting it by 60%."
What factors do you find are most worth spending time to consider?
How might you express those factors in making a go/no-go decision on a project?

Examples, in no particular order:

Value Factors: What will we get from this software?

capabilities - but then I ask, what is the value of each capability?
What is the "total market available" for this software/feature?
How much of that market can we expect to get?
What new markets will this get us into?
What cost(s) will this feature help us avoid or reduce?
What value does this bring to our team - new skills, experience, etc.
How much fund will this be?
Synergy with other projects?
What is the time-to-market value? (what is the value of releasing early vs. later?) Taken to the extreme, that question turns into a cost question: "What is the cost of not releasing at all?"
Reputation value: What value does this bring to our brand?

Cost Factors: What will it cost us?

Labor costs
Hardware costs
Licensing costs
Costs associated with various risk factors:
Reputation cost for overreaching.
Human cost (burn-out, staff turnover) of doing too much.
New or increased legal or financial liabilities.
Delay to other projects.

Technorati Tags: estimating, software development

JUnit-Style XML from Perl Test Files

2007-01-21T19:17:00.000-08:00

2009-05-01 Update: Perl module that provides a test harness that runs TAP tests and outputsJUnit-compatible XML

Here is an experimental program that runs Perl test files and produces the same sort of XML output as the <junit> ant task.Getting this XML output is helpful when running Perl tests under CruiseControl.

#!/usr/bin/perl

use strict;
use warnings;

use Test::Harness::Straps;
use Time::HiRes qw(gettimeofday tv_interval);
use XML::Generator ':noimport';

my @files = @ARGV;

my $strap     = Test::Harness::Straps->new;
my $generator = XML::Generator->new(':pretty');

my @properties = _get_properties($generator);
my $test_results = _run_tests( $strap, $generator, @files );

my $xml = _get_junit_xml( $generator, \@properties, $test_results );

print "$xml\n";

exit;

#-------------------------------------------------------------------------------

sub _get_junit_xml {
    my ( $generator, $properties, $test_results ) = @_;

    my $system_out = 'system-out';
    my $system_err = 'system-err';
    my $xml        = '';
    $xml .= "\n";
    $xml .= $generator->testsuite(
        {
            errors   => 0,
            failures => $test_results->{total_failures},
            name     => 'name of the test suite',
            tests    => $test_results->{total_tests},
            'time'   => $test_results->{total_time},
        },
        $generator->properties(@properties),
        @{ $test_results->{test_cases} },
        $generator->$system_out(),
        $generator->$system_err(),

    );
    return $xml;
}

sub _run_tests {
    my ( $strap, $generator, @files ) = @_;
    my @test_cases     = ();
    my $total_tests    = 0;
    my $total_time     = 0;
    my $total_failures = 0;

    foreach my $test_file (@files) {
        my $start_time   = [gettimeofday];
        my $file_results = $strap->analyze_file($test_file);
        my $elapsed_time = tv_interval( $start_time, [gettimeofday] );
        $total_time += $elapsed_time;
        foreach my $assertion ( @{ $file_results->details } ) {
            if ( _skip($assertion) ) {
                next;
            }
            $total_tests++;
            $total_failures += _is_failure($assertion);
            my $test_case = {
                classname => $test_file,
                name      => $assertion->{name},
                'time'    => 0,
            };
            push @test_cases, $generator->testcase($test_case);
        }
    }
    my $test_results = {
        total_time     => $total_time,
        test_cases     => \@test_cases,
        total_tests    => $total_tests,
        total_failures => $total_failures,
    };
    return $test_results;
}

sub _skip {
    my $assertion = shift;
    return $assertion->{type} =~ / skip | todo /x;
}

sub _is_failure {
    my $assertion = shift;
    return !$assertion->{ok};
}

sub _get_properties {
    my $generator  = shift;
    my @properties = ();
    foreach my $key ( sort keys %ENV ) {
        push @properties,
          $generator->property( { name => "$key", value => $ENV{$key} } );
    }
    return @properties;
}

__END__

=head1 NAME

junit_xml.pl - Run Perl tests and get JUnit-style XML output

=head1 SYNOPSIS

   junit_xml.pl file1 [ file2 ... ]

=head1 DESCRIPTION

Experimental script to run perl test files and produce the
same XML output as produced by the <junit> ant task.

=head1 DEPENDENCIES

 Test::Harness
 Time::HiRes
 XML::Generator 

=head1 BUGS

  - Doesn't do anything with the STDERR from tests.
  - Doesn't fill in the 'errors' attribute in the  <testsuite> element.
  - Doesn't handle when all tests in file are skipped (skip_all)
  - Doesn't get the elapsed time for each 'test' (i.e. assertion.)


=head1 AUTHOR

Matisse Enzer <matisse@matisse.net>

=head1 COPYRIGHT & LICENSE

Copyright (c) 2007 Matisse Enzer. All Rights Reserved.

This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
=cut

Updates: This post was originally published on 2007-01-21.2008-05-26: I noticed that Justin Mason has created a better script for converting TAP output to JUnit-style XML

Technorati Tags: Perl, software testing

Unix shell: Finding the run-time directory of a script

2007-01-21T12:01:00.001-08:00

I've been trying to come up with an elegant way, in a shell script, to find the full path of the directory in which the script is located.

So far, I have this, which works for bash but not for sh (sh does not support substring expansion on variables):

 #!/usr/local/bin/bash -x
 # Finds the full path to the directory containing this script
 
 dir_containing_this_script=""
 script_dirname=`dirname $0`
 first_char="${script_dirname:0:1}" ; # Starting at index 0, 1 character
 case "$first_char" in
 ("/")
     # It's a full path. Use it unmodified.
     dir_containing_this_script="${script_dirname}"
 ;;
 (*)
     # Strip leading . characters
     while [ "${first_char}" = "." ]; do
         script_dirname="${script_dirname:1}" ; # substring from index 1 to end
         first_char="${script_dirname:0:1}"
     done
     current_dir=`pwd`
     if [ -s "${script_dirname}" ] ; then
         dir_containing_this_script="${current_dir}/${script_dirname}"
     else 
         dir_containing_this_script="${current_dir}"
     fi
 ;;
 esac
 
 echo "$dir_containing_this_script"

Update: Eric M on The WELL posted this most excellent solution:


 dn=`dirname $0`
 path=`(cd $dn; pwd)`
 echo "path = $path"

Technorati Tags: programming, unix, unix shell

Super Easy Graphics Programming

2007-01-19T00:05:00.001-08:00

Eric Townsend pointed me to Processing - super easy programming environment for creating graphics programs.

Here's an applet I generated from it in a few minutes work, starting with an example Eric posted on The WELL.

/// start
void setup() {
  size(600,600);
}

void draw(){
  background(255);

  int left_x = 0;
  int right_x = width;
  int top_y = 0;
  int bottom_y = height;
  int light_green = #99FF99;
  int light_blue = #66CCFF;
  int light_yellow = #FFCC66;
  int pale_red = #FF3366;

  for (int n=0; n < 100; n++) {
    int y_of_n = n * (bottom_y/100);
    int x_of_n = n * (right_x/100);

    stroke(pale_red);
    line(left_x,y_of_n,mouseX,mouseY);

    stroke(light_yellow);
    line(right_x,y_of_n,mouseX,mouseY);

    stroke(light_blue);
    line(x_of_n,0,mouseX,mouseY);

    stroke(light_green);
    line(x_of_n,bottom_y,mouseX,mouseY);
  }
}

/// end

Technorati Tags: graphics, programming

Provider Injection, not Dependency Injection

2006-12-26T21:04:00.000-08:00

The term "provider injection" should replace the term "dependency injection."

The term misleads by seeming to say that you are "injecting" a dependency. This would mean that the thing got the "dependency" injected into it now depends upon something that it didn't depend upon before. This is not what "dependency injection" means.

The term "dependency injection" actually means that if Object A depends upon having a "B" object that you "inject" a B object into object A (instead of object A fetching or creating a B on its own.) A classic example would be a Person object that depends upon having a database connection in order to create/update/edit/delete people in the database. Instead of the Person object creating its own database connection it gets one passed to it (i.e. "injected") perhaps as an argument to its constructor. But, see, you are not injecting a dependency. You are injecting a provider.

A "dependency" is not the thing upon which you depend. The thing you depend upon is a tool, resource, skill, or capability and you get those things by making them yourself, or from a provider.

So, I think the term "provider injection" should replace the term "dependency injection."

By the way, I want to thank Mike Ward for originally introducing me to the term "dependency injection" - whatever phrase is used, the actual practice is one I have done in the past and it is good to have a phrase to describe this technique.

See also:
Wikipedia entry on Dependency Injection (which I have attempted to edit.)
Inversion of Control Containers and the Dependency Injection pattern - 2004 article by Martin Fowler
Spring in Action - Book on Spring

Technorati Tags: inversion of control, software development

countperl - count lines, packages, subs and complexity of Perl files

2006-12-09T15:22:00.000-08:00

I recently released a new version of Perl::Metrics::Simple (0.03) that includes the countperl script. The program reports on how complicated your Perl code is - giving you direction on where to start refactoring it to make it easier to understand, debug, and maintain. Try to keep the McCabe Complexity at 9 or less for every subroutine and "main" section of your code.
countperl is a command line tool that you execute with a list of one or more files andor directories. The program examines the named files and recursivesly searches named directories for Perl files.
The countperl program produces a report on STDOUT of total lines, packages, subroutines/methods, the minimum, maximum, mean, standard deviation, and median size and mccabe_complexity (aka cyclomatic complexity) of subroutines and the 'main' portion of each file (everything not in a subroutine.)

Output Format

Line counts do not include comments nor pod.
The current output format is human-readable text. For example, a report based on analyzing three files might look like this:

 Perl files found:                3

 Counts
 ------
 total code lines:       856
 lines of non-sub code:  450
 packages found:           3
 subs/methods:            42

 Subroutine/Method Size
 ----------------------
 min:                  3 lines
 max:                  32 lines
 mean:                 9.67 lines
 std. deviation:       7.03
 median:               7.50

 McCabe Complexity
 -----------------
 Code not in any subroutine::
 min:                  1
 max                   1
 mean:                 1.00
 std. deviation:       0.00
 median:               1.00

 Subroutines/Methods:
 min:                  1
 max:                  5
 avg:                  1.00
 std. deviation:       1.36
 median:               1.00

 Tab-delimited list of subroutines, with most complex at top
 -----------------------------------------------------------
 complexity      sub     path    size
 5       is_perl_file    lib/Perl/Metrics/Simple.pm      11
 5       _has_perl_shebang       lib/Perl/Metrics/Simple.pm      13
 5       _init   lib/Perl/Metrics/Simple/Analysis/File.pm        30
 4       find_files      lib/Perl/Metrics/Simple.pm      11
 4       new     lib/Perl/Metrics/Simple/Analysis.pm     10
 4       is_ref  lib/Perl/Metrics/Simple/Analysis.pm     8

Chris Chedgey has a posting that describes a common situation - you have accumulated a huge pile of "complexity debt" - well, using countperl is one tool to help "keep a lid on it."

Technorati Tags: Perl, programming, refactoring, software development, software testing, static analysis

Very Simple Wrapper for Perl DBI

2006-11-02T05:51:00.000-08:00

I've released a new Perl module: DBIx::Wrapper::VerySimple which provides a very simple (object-oriented) wrapper around DBI.

DBIx::Wrapper::VerySimple provides three methods that between them cover about 98% of the SQL calls I've seen in Perl code over the years:

fetch_all() - run a SQL statement (typically a SELECT statement) and get back an arrayref of hashrefs (one hashref for each result row.)

fetch_hash() - run a SQL statement (typically a SELECT statement) and get back a single hashref (for just one row.)

Do() - run a non-SELECT statement such as CREATE or DELETE.

DBIx::Wrapper::VerySimple will use bind-variables if you pass them as additional arguments to fetch_all(), fetch_hash() or Do().

DBIx::Wrapper::VerySimple also provides a get_args() method and a dbh() method. get_args() returns the arguments originally passed to new() so you can re-connect, etc. if need be. dbh() returns the raw DBI databse handle so you have ready access to all the features of DBI.

DBIx::Wrapper::VerySimple is available on the CPAN: http://search.cpan.org/dist/DBIx-Wrapper-VerySimple/

Technorati tags: CPAN, DBI, Perl

Perl::Metrics::Simple

2006-10-03T22:25:00.000-07:00

Counts files, packages, subroutines, and calculates cyclomatic complexity of Perl files.

I recently released an alpha version of new Perl module: Perl::Metrics::Simple

There is an included script, in the examples/ directory which produces output like this:


Perl Files:      $file_count

Line Counts
-----------
lines:           $lines
packages:        $package_count
subs:            $sub_count
all main code:   $main_stats->{lines}

min. sub size:   $lines{min} lines
max. sub size:   $lines{max} lines
avg. sub size:   $lines{average} lines
median sub size: $lines{median}

McCabe Complexity
-----------------
min. main:    $main_complexity{min}
max. main:    $main_complexity{max}
median main:  $main_complexity{median}
average main: $main_complexity{average}

subs:
min:             $complexity{min}
max:             $complexity{max}
avg:             $complexity{average}
median:          $complexity{median}
std. deviation:  $complexity{standard_deviation}

Ruby plug-in for Eclipse

2006-09-22T07:28:00.000-07:00

I recently found out there is a Ruby plug-in for the Eclipse IDE: The "Ruby Development Tool."

Quick install instructions:

Start up Eclipse.
Help > Software Updates > Find and Install...
Select "Search for new features to install"
Click "Next"
Click "New Remote Site..."
Enter the URL of stable release branch is: http://updatesite.rubypeople.org/release
Click "OK"
Click "Finish"

Ruby Development Tool (RDT) web site: http://rubyeclipse.sourceforge.net/index.rdt.html

Article on using RDT: http://www-128.ibm.com/developerworks/opensource/library/os-rubyeclipse/

Count Perl Code

2006-09-03T18:14:00.000-07:00

I've started working on a module to analyze perl code report of files, lines, packages, subroutines, etc.

A report could look like this:


% analyze.pl path/to/directory/of/perl/code

files:     39
lines:     15929
packages:  39
subs:      336

The module is (very tentively) named Perl::Code::Analyze and uses
Adam Kennedy's PPI module for the real work.

A (very) alpha version of the module is at
http://g5-imac.matisse.net/~matisse/Perl-Code-Analyze-0.01

Here's an example of a script that would use Perl::Code::Analyze
to produce the report shown above:


#!/usr/bin/perl

use strict;
use warnings;
use Perl::Code::Analyze;
my $analzyer = Perl::Code::Analyze->new;

my $analysis = $analzyer->analyze_files(@ARGV);

my $file_count    = $analysis->file_count;
my $package_count = $analysis->package_count;
my $sub_count     = $analysis->sub_count;
my $lines         = $analysis->lines;

print <<"EOS";

files:     $file_count
lines:     $lines
packages:  $package_count
subs:      $sub_count

EOS

exit;

Apple releases Launchd as Open Source

2006-08-31T07:36:00.000-07:00

Apple has released their launchd process manager under the Apache Open Source License (version 2.0)

Launchd combines most of the features of the venerable Unix cron and init facilities. You can use launchd to make sure a process is always running ("watchdogging"), to run jobs at specific times, to run jobs when/if a file appars in a specified directory, etc.

I cover the basics of launchd in my book, "Unix for Mac OS X Tiger", and ars technicha covers it in their Tiger review.

There is already a FreeBSD port of launchd.

Macscripter.net has an article describing how to use launchd with AppleScript to access a Flashdrive.

Mock Classes in Perl Unit Tests

2006-08-20T21:05:00.000-07:00

UPDATE:
November 2, 2006: I finally released the Wrapper module described here on the CPAN system.

Today I added unit tests to a Perl module that uses the DBI module. My module, DBIx::Wrapper::VerySimple is one that I wrote years ago.

The tests use three tiny mock classes that take the place of the real DBI module. This allows the units tests to run in complete isolation from the actual DBI module.

Back when I wrote DBIx::Wrapper::VerySimple wasn't experienced enough to bother creating unit tests for my code. These days I create unit tests any time I create a new module for a project and sometimes for scripts as well.

The challenge in this case was that constructor method, DBIx::Wrapper::VerySimple->new() calls DBI->connect(), and I didn't want my unit tests to require connecting to an actual database. My solution is to have three tiny mock classes in my test code including a DBI.pm that the tests load before DBI::Wrapper can load the real DBI.pm.

Here's what my mock DBI.pm looks like:


#  Mock class - for testing only
package DBI;
use strict;
use warnings;

# warn 'Loading mock library ' . __FILE__;
my $MOCK_DBH_CLASS = 'DBI::Mock::dbh';

my %ARGS = ();

sub connect {
   my ( $class, @args ) = @_;
  my $fake_dbh = {};
   bless $fake_dbh, $MOCK_DBH_CLASS;
  $ARGS{$fake_dbh} = \@args;
  return $fake_dbh;
}
1;

My test script loads the mock DBI.pm and two other mock classes before DBI::Wrapper is loaded for testing. This way, when DBI::Wrapper is compiled my mock DBI.pm is used instead of the real one:

# Ensure that DBI::Wrapper loads our mock DBI.pm
use lib "$Bin/mock_lib";
use DBI;
use DBI::Mock::dbh;
use DBI::Mock::sth;

This approaches works very well, and I was able to create unit tests that intercept all the calls that DBI::Wrapper makes that would normally go to the real DBI, and my intercepting these I can check that DBI::Wrapper is passing the expected values to DBI. I am deliberately not testing the real DBI module which has its own extensive set of unit tests. I merely test that my module will make the expected calls to DBI.

More about DBI::Wrapper

The module is available online at http://www.matisse.net/perl-modules/DBI/Wrapper/
The version with the new unit tests is version 0.04.

From the README:


DBI::Wrapper is a simple module that provides a high-level interface
to the Perl DBI module. The provided methods are for fetching
a single record (returns a hash-ref), many records (returns
an array-ref of hash-refs), and for executing a non-select statement
(returns a result code).

The intention here is that your application will have much cleaner code,
so instead of writing:

$sql = 'SELECT name,address FROM $table WHERE zipcode=?';
$sth = $dbh->prepare($sql);
$rv  = $sth->execute($zipcode);
@found_rows;
while ( my $hash_ref = $sth->fetchrow_hashref ) {
push( @found_rows, $hash_ref );
}

You would write:

$sql = 'SELECT name,address FROM $table WHERE zipcode=?';
$found_rows = $wrapper->FetchAll($sql,$zipcode); # An array_ref of hash_refs

I wrote the my version of DBI::Wrapper several years ago after I got the idea from a co-worker when I was doing a gig at TechTV.

Compare BASIC, Ruby, Python, PHP, Perl, JavaScript, Lisp, False, Haskell etc.

2006-08-10T08:03:00.000-07:00

Paul Bissex wrote three versions of a simple game, and posted it on E-Scribe news: http://e-scribe.com/news/193
Readers have contributes more versions.

Comparing Pair Programming to Solo Programming

2006-06-02T06:50:00.000-07:00

Brian Slesinsky wrote recently comparing Pair Programming to Code Reviews and argues that Pair Programming is better. I agree with his reasoning. I also think we need more hard-data on comparison of pairing vs. solo programming. It is a multi-dimensional issue, involving at least:

Total developer time spent.
Code quality and increase/reduction in the cost of product quality (more bugs == higher cost.)
Time-to-market. Two people spending 70 hours in parallel is faster to market than one person spending 100 hours.
Personalities and social dynamics. People have widely differing and strong held feelings about pairing vs. solo programming.

Technorati Tags: agile, extreme programming, pair programming, programming, code review, software development, XP

How much eXtremism is too extreme?

2006-06-01T08:33:00.000-07:00

Blain Buxton recently wrote about how Pair Programming all the time could be bad, and in general makes the case for not being extreme about being eXtreme.

I think the most important point Blaine makes is that one should always be focused on what is best for the process, not on adhering to any particular technique.

Technorati Tags: agile, extreme programming, pair programming, software development, XP

Pair-Programming Experiment at Stanford University

2006-05-31T08:34:00.000-07:00

Stanford University is in the middle of a formal experiment on Pair Programming. I participated in the experiment this past weekend and had a lot of fun and, hopefully, helped advanced the state of knowledge about this controversial software development technique.

A PDF document describing the experiment is available at http://hci.stanford.edu/research/pairs/PairProgramming-WhenWhy.pdf

The experiment is currently in the second ("Laboratory Experiment") phase as described in that document.
In the first phase ("Ethnographic Field Study") of the experiment the researchers visited two companies where pair-programming is regularly practiced and observed and recorded audio of programming pairs. These observations helped the researchers develop some hypothesis which may be checked by further work in the experiment.

The researchers are focusing on the interaction between the people in the pairs (the "socio-cognitive factors" is how they say it.) The current phase of the experiment involves controlled tests where a pair of programmers or a solo programmer complete a warmup task and then a larger task (which takes around 5-6 hours all together.) The programmers are recorded via audio, video, and screen captures.

During my pairing session this past weekend we talked a bit about the notion that once we humans have a goal we often have a strong impulse to start acting towards that goal, without necessarily doing much planning or testing - like driving nails before deciding where, exactly to drive the nails, and that we continue with our actions without doing much checking if we are in fact heading towards our goal. I don't think that Pair Programming stops individuals from having this impulse, but the presence of a second person makes it more likely, perhaps, that someone else will stop us. Hence my new joking slogan: "Pair Programming: It's not twice as smart, it's half as dumb!"

Pair Programming as a formally recognized technique has been around for over a decade now, and as an informal reality I would guess it has been around for as long as there has programming. There has been only a little formal study of Pair Programming though, and Pair Programming is perhaps the most controversial technique in the eXtreme Programming methodology, touching as it does directly on people's self-image and personalities.

I hope this experiment will help advance the state of knowledge about software development in general, and Pair Programming in particular, so that we can make better decisions about how to build things.

The experiment is led by Robert P. Plummer, PhD., a Lecturer in the Stanford Department of Computer Science. Inquiries about the experiment can be sent to experiment at cs.stanford.edu.

Technorati Tags: agile, extreme programming, pair programming, programming, software development

Test-Driven Development in the Physical World

2006-05-31T08:13:00.000-07:00

It's occurred to me that we routinely practice Test Driven Development in the physical world, such as building houses.

Consider how we use a "test first" approach in construction:

Typically, if you want a hole in the wall 30 inches below the ceiling:
1. You take a ruler and make a mark on the wall 30" below the ceiling.
2. You drill a hole where the mark is.
3. If your hole is where the mark is/was, your test passes, otherwise, go to step 1.

Now consider what that would be like without doing it "test first":

1. You drill a hole in the wall.
2. You measure hole far from the ceiling the hole is.
3. If the hole is 30" from the ceiling, you win . Otherwise, go to step 1.

Software Best Practices Wiki?

2006-05-24T22:28:00.000-07:00

I've been thinking about creating a wiki for software development "best practices."
Something that might contain entries like this:

1. Where Applications Save Data

Many applications need to save data between invocations of the application.

Some examples are:

User Preferences.
Documents or other work product from the application (web pages, spreadsheet, reports, images, etc.)
Cache files.
Other long-lived data (bookeeping data, emails, audit trails, etc.)

1.1. Forces at Work

Some of the forces at work in determing where an application should save data include:

Access ability: the application needs write and read access.
Upgradeability: some data must survive a software upgrade.
Multiple users: some applications are used by many users.
Privacy and security: Some data must be protected from unauthorized access.

The types of data an application saves are:

Temporary vs. Long-Lived
User-associated vs. Application-associated
Internal use by the application vs. Suitable for distribution outside the application environment.

1.2. General Principles
Application shall:

Save Long-Lived data where it will survive an upgrade.
Save Temporary data where it is easily garbage-collected.
Save per-user data in a place belonging to the user.
Save data for distribution in a place the user is explicitly informed about.
Use encryption to help secure privacy.

Technorati Tags: software development

Wiki's in the Workplace

2006-05-15T10:11:00.000-07:00

Peter Thoeny and Dan Woods, co-authors of a Book on Wikis in the Workplace have started a company to help business use Wikis: StructuredWikis: http://www.structuredwikis.com/

I've seen wiki engines used at three very different organizations: The Burning Man tech-team, Technorati.com, and Barclays Global Investors. I think wikis have a important role to play in almost all modern businesses that have an Intranet of any kind.

Technorati Tags: intranet, wiki

Trackback Explained

2006-05-13T08:57:00.000-07:00

Suzanne Stefanac explains trackbacks: http://www.dispatchesfromblogistan.com/trackback-demystified

Technorati Tags: trackback, blogging

Ruby / Flash Gateway: Alph

2006-04-24T06:59:00.000-07:00

I saw a cool demo yesterday of Alph. Alph allows you to use Ruby to control a Flash movie.

Technorati Tags: flash, programming, ruby

The WELL is Down!

2006-04-14T15:25:00.000-07:00

My long-time online home, The Whole Earth 'Lectronic Link has been unavailable for several hours now - the longest unplanned outage I can recall in over 10 years.

I no longer have any staff member phone numbers but I called their office and spoke with Gail Williams, Director of Community and she pointed me to http://www.salon.com/wellstatus/ - where recent status info should be available. She also told me that people have sent flowers and left goodwill messages ("beams") on the WELL's voice mail.

Update: Looks like the WELL's command-line interface came back up just before midnight April 14th, Pacific Time.

Wanted: Blogging Platform with Revision History

2006-04-11T08:54:00.000-07:00

I'd love to have a blogging platform that supports a Revision History of Published Posts:

Desired features:

Each published version of a posting would be saved.
Readers would be able to see a list of versions.
Reader can choose to view a specific version.
Reader may compare any two versions.

I'm imagining that each posting would be stored under some kind of Revision Control system, similar to how wiki's treat pages.

I'd be glad to help make this happen.

I've posted this in the BloggerDev group - if you are reading this and agree, please go there and post a "me too" comment.

Technorati Tags: blogging, revision control

Making Things is a Fractal Process

2006-04-09T20:20:00.000-07:00

/*
* All building and making of things involves a fractal (recursive) process
* like this pseudo-code:
* Takes a set of Requirements and returns something new
*/
public Thing makeNewThing ( Requirements requirements ) {
    Thing newThing = ();
    while ( requirements.not_satisfied ) {
        Things requiredPieces = requirements.whatCanWeMakeOneFrom;
        Things piecesWeHave   =
           this.whatDoWeHaveAlready(requirements,requiredPieces);
        Things piecesNeeded   =
            requiredPieces - piecesWehave;
        newThing.assemblePieces(piecesWeHave);
        foreach Thing neededPiece ( piecesNeeded ) {
            piecesWeHave.add( makeSomething(neededPiece) );
            newThing.assemblePieces(piecesWeHave);
        }
        requirements.check(newThing);
    }
    return newThing;
}

Technorati Tags: construction, programming, software development

Run Windows, Mac OS X, Solaris, and Linux Simultaneously

2006-04-09T17:18:00.000-07:00

See: Parallels Workstation: http://www.parallels.com/en/products/workstation/

The folks at Parallels, Inc. have made a real breakthrough - building upon Intel's virtualization feature of their newest CPUs, Parallels allows you to boot into one operating system, and then run one or more others as "hosted" operating system in windows in the primary one.

In other words: You boot into say, Mac OS X, and then run a real copy of Windows XP, in a window. The hosted OS is not running on a chip emulator - each OS is running as a virtual machine.

For example:

Windows XP "guest" on Mac OS X "primary"
Windows 3.11, Solaris 10.0 on top of Mac OS
See also:
jtl's posting: http://www.jtl.us/mt-main/archives/000602.html
The official Parallels Blog
Paul Stamatiou's blog has a discussion comparing Parallels to Bootcamp.

Technorati Tags: Mac OS X, virtualization, Windows

Software Development is like Building Construction

2006-04-09T10:39:00.000-07:00

The process of Software Development is a lot like the process of Building Construction, and although they also have important differences, these differences are mainly differences of degree rather than kind.

Software folks occasionally make a big deal of the differences between software development and building construction, and building trades/architecture folks often think you cannot do iterative design on buildings.

The fact is, software development and building construction have many important similarities, and many processes that are effective in both.

Both software development and building construction involves the marshaling of numerous interdependent systems designed, built, and assembled by a variety of highly specialized people.

Dependencies

In the software world we have architecture issues (client/server, message-passing, batch processing, micro-kernel, etc.) data structures (databases), business logic, graphic and other user-interface design, etc.

In the world of buildings we have architecture, foundation, frame or shell, electrical, plumbing, wall coverings, HVAC, etc.

Both software development and building construction have numerous layers of dependencies. There are many variations on the actual stack of what depends upon what, but there are always dependencies.

Typical examples of the stack of dependencies in software are hardware, then the operating system, then the programming language, then some kind of data structure, then something to manipulate the data, etc. Buildings too have their stack of dependencies: connection to the Earth (foundation), the load-bearing frame or envelope, utilities, skin/weather-proofing, etc.

Some might say that software may be "built" in many different ways, but that buildings must be built from the ground up. Well, if you think buildings must be built ground-up, do a search for "Linn Cove Viaduct" and see http://www.dot.state.oh.us/se/SI9/19Freeby.pdf, and consider how a space station can be built in orbit.

Incremental Design

These days (early 21st Century) the concept of incremental design is reasonably well known in the software world, and is arguably becoming more popular. There is a long history of incremental design in building - think of the Wright brothers many iterations on their aircraft design and their invention of and use of wind tunnels to test and refine (shall we say "refactor"?) their designs.

Both mathematical and physical models have been in the repertoire of the making process for thousands of years.

These days (2006) we in the software world try to use intensive tests (such as unit tests) and clever modeling in our design/development processes.

Almost 20 years ago I was building full-scale mockups, tests, and experiments of buildings as part of the design process and it works. I was working with Chris Alexander's Center for Environmental Structure and among many other examples of iterative design, complete with unit tests was the work we did on the exterior walls of the Julian Street Homeless Shelter in San Jose ( see this exterior photo of the main building, and this interior of the dining hall - those are sprayed-concrete trusses, also the results of a test-driven design process.)

The exterior wall system went through many iterations, and there were many kinds of tests, of both the visual and physical composition. In each test we would establish a certain standard or required result - sort of making an assertion about the design or structure, and then make a change or build something to implement the assertion.

Some of the tests were physical such as "Is the cover glaze sufficiently free of cracks?" Probably the most frequent kind of tests were tests to verify that a particular feature or system maintained or improved the life in the overall structure. For example, such a test might be "Check that the way the tiles are embedded creates a tangible border that increases the life of the whole wall." And then we would embed tiles using one or another method and check, if the test passed.

Conclusion

The design and development of software and the design and development of the built environment, like all building processes are iterative processes that involve the repeated assembly of existing materials in new combinations and structures, informed by human creativity and driven by human needs and desires. Humans have been building physical structures for many thousands of years, and some techniques have remained essential unchanged in all that time, while other techniques and materials have come into existence more, or less, recently. Those who build - builders of any kind - would do well to learn from each other as builders, and learn to search for the commonalities in our processes, successes, and failures, and to recognize objectively the differences, which are fewer than is commonly believed.

Thanks to Jeff Thalhammer for 'code review' on this document.

See Also

Review of Christopher Alexander's "The Nature of Order", in Katarxis Nº 3
A contrary opinion: http://www.agilemanagement.net/Articles/Weblog/ConstructionAnalogyAgain.html
Another contrary opinion: http://www.jamesshore.com/Blog/That-Damned-Construction-Analogy.html in which James Shore argues that "Ultimately, construction is about dealing with physical objects.", which I disagree with: In my view, ultimately construction is about making things. I suspect that Mr. Shore has never built a building.
How Buildings Learn: What Happens After They're Built (Viking-Penguin, 1994; in the UK, Orion Books). The author, Stewart Brand says "It was written (and designed and laid out in detail) to change the practice of building and the use of buildings the way Chris Alexander's A Pattern Language and Jane Jacobs's The Death and Life of Great American Cities have done."
Martin Fowler's Refactoring Home Page
Here's another disagreeing post - this one from Johanna Rothman.
George Dinwiddie ponders this issue.

Technorati Tags: buildings, construction, programming, software, software development

The WELL Gopher

2006-04-08T13:58:00.000-07:00

UPDATE - (June 2009) The WELL's Gopher server was decommissioned some months back, but the content is still available via a web server at: http://www.well.com/gopher/

The WELL is an online discussion system that started in 1985. At the very end of 1991, in fact, on New Years' Eve, The WELL connected to the Internet (via 56K connection to BARRNet, router configuration by Erik Fair.)

In those days I was the Customer Support Manager at The WELL and I wanted us to give something back to the Internet community. In those days "anonymous FTP" sites were a common way for organizations to share information with the public over the Internet. I suggested that The WELL create an anonymous FTP site where we would provide access to interesting information, drawing heavily on our association with The Whole Earth Catalog (The WELL was half owned by The POINT Foundation, publisher of The Whole Earth Catalog, and we were in the same building with the catalog staff.)

I recruited a small group of volunteer WELL users to be the editorial staff of the new site: Jerod Pore, Eric S. Theise, Jon Lebkowsky, and Paul Holbrook, and we started discussing what should be in the new site. During this (online) discussion a WELL user who was very involved with the Internet, Ed Vielmetti, suggested we check out this cool new rodent-based technology developed at the University of Michigan Minnesota (the "Golden Gophers"). This new thing was called "gopher", and I immediately saw that it was much easier to use than FTP.

Eric Theise and I had a bit of a fight over that - Eric felt that FTP was the widely used and well known standard and we'd be cutting out all the people who didn't yet have access to a gopher client. I was all steve-jobsian about it "the interface is so much better, people will get a gopher client, this is the future, blah blah blah". I think it was the one place where I strongly asserted my WELL-staff role. We went with gopher.

The content in The WELL Gopher was a direct outgrowth of the WELL's connection to The Whole Earth Review - part of my evil plan was to bring the editorial approach of WER to cyberspace - in fact the top-level categories in the gopher were originally taken directly from the categories that the Whole Earth Catalog used.

There was a point when the WELL gopher and the spies.com gopher were the two hottest places in gopherspace. This all came down to three really important factors:

Content: We had great editors like Jon, Jerod, Eric and Paul choosing great stuff. See this great story, "Forces Adrift, a Tale of Our Forces Afloat", by Chuck Charlton.
Content: We were choosing from a pool of ideas that mapped very well onto the population using cyberspace. Roger Karraker's "Highways of the Mind" article is still relevent.
Content: We had exclusive content - no offsite links for the first year or so. With maybe a couple exceptions the WELL gopher was the exclusive online location of all the content. This made us editors think more, and choose less.

These days there are many things like the WELL gopher, and nothing like it - like a magazibne with a particular editorial group, the result is really all about the people and historical circumstances at the times of creation.

Notes:

Gopherspace is part of webspace. "The web", at least circa 1993 was all the resources reachable via (at least) the FTP, gopher, and HTTP protocols. You could throw in WAIS, telnet and maybe a couple of others.
The WELL gopher did (and does) utilize a server that responds to both the gopher and HTTP protocols, so you can reach it with the URL gopher://gopher.well.com/ or http://gopher.well.com:70/ Initially the server only handled the gopher protocol but was soon switched to the GN server which handles both protocols, so even if you mistakenly think that a web site must utilize HTTP, the WELL gopher still qualifies.

Technorati Tags: gopher, history

The WELL Turns 21

2006-04-01T19:42:00.000-08:00

Jennifer made this excellent post about The WELL:
http://fierce.jnfr.com/archives/2006/04/the_well_turns.html

I've been using The WELL since 1987, and it's been around since 1985. If you want to read about it on the web, read this, but if you want to use it, learn to use the command-line interface and and connect to The WELL via SSH, not with a web browser.

Mini-Microsoft: Vista 2007. Fire the leadership now!

2006-03-30T08:01:00.000-08:00

Fascinating stream of comments from many who appear to be Microsoft employees:
Mini-Microsoft: Vista 2007. Fire the leadership now!

Net Neutrality - where are we now?

2006-03-26T09:45:00.000-08:00

Does this sound familiar:

The battle is about who will build, own, use and pay for the high-speed data highways of the future and whether their content will be censored.

Roger Karraker wrote that in his 1991 article, "Highways of the Mind" and the article is still relevant today. Have a look.

(See also: The Communications section of The WELL gopher.)

Perl BEGIN Blocks Considered Harmful

2006-03-18T11:43:00.000-08:00

Adam Kennedy pointed this out to me:

Create a new Perl file containing the following:
```
BEGIN {
   print "hello world\n";
}
```

Check the syntax with
```
perl -c filename
```

This will print hello world, even though "all" you did was compile the file.

What's going on here?

Well, BEGIN blocks get executed when Perl compiles the file.

So what?

If you run perl -c on a file that contains nasty code in a BEGIN block, you're screwed.

Consider this:

You associate the filename extension .pm with a fancy Perl editor, like Komodo, or Affrus.
You click on a link in your web browser.
The web server redirects you to a URL for nasty_file.pm
Your browser opens the associated editor and performs a"syntax check" by compiling the file
The file's BEGIN block has naughty code in it...

You're screwed.

So, keep in mind that "just compiling" Perl code may actually execute the code, so, be careful!

Here's a bug report on this subject that I filed for the Eclipse/EPIC Perl IDE.

Testing if a Perl script compiles - compile_ok

2006-03-16T08:27:00.000-08:00

A co-worker and I were pair programming a test suite the other day, and needed to test if a Perl script compiles - not a library or module but an executeable script, so the typical:

    require_ok()
    use_ok()

functions provided by Test::More don't do exactly what we wanted.

The short story is that we ended up doing something like this:

  eval {
     $output = `perl -c $script 2>&1`;
     chomp $output;
  };
  is($output, "$script syntax OK", "$script compiles");

We later looked for a more general, better solution, and a colleague posted on the perl-qa mailing list, but the bottom line is that a more elegant solution still involves executing a new perl interpreter, but in a platform-independent way (perhaps using IPC::Open3 or something.) It's also likely that a better test is to ignore the output altogether and just check the return code from the compile process (the call to perl -c.)

March 18, 2006 update: Jeff Thalhammer found that a colleague Pierre Denis provides a syntax_ok method in Test::Strict that does what we want.
More update - I was prodded by Randall Schwartz to post why you should be careful when "only" compiling Perl code - see BEGIN Blocks Considered Harmful.

Tags: perl, testing

Swimming Snake Robot

2006-03-16T08:24:00.000-08:00

OK, ready to be creeped-out and fascinated?

http://www.hackaday.com/entry/1234000957073583/

Teen Use of MySpace

2006-02-24T08:40:00.000-08:00

A transcript of a rather cogent and articulate talk by Danah Boyd on teen use of MySpace.com:
http://www.danah.org/papers/AAAS2006.html

RFC: Mozilla Architecture Changes

2006-02-21T08:48:00.000-08:00

Dave Liebreich is looking for people to participate in conversations about proposed major changes in the architecture of Mozilla.

Dave provided the following URLs for current discussions about the issues (garbage collection approach and using exceptions) and asks that interested people jump in and participate:

Mozilla Wiki
Mozillazine.org
Benjamin Smedbergs on Exceptions
Benjamin Smedbergs on Garbage Collection

Should Arab Media Take Lessons from the West?

2006-02-21T08:43:00.000-08:00

An excellent debate among journalists from and working in the Arab world, debating the motion "This house believes that the Arab media need no lessons in journalism from the West."

Bunchball - put interactive stuff in your blog

2006-02-18T09:01:00.000-08:00

http://www.bunchball.com/

The idea is you put a code snippet in your web page, blog etc. and then you can upload photos etc. to bunchballs servers and they show up in your page. Also does games, and various other interactive thingies.

Perl IDE Demonstration and Comparison

2006-02-17T08:06:00.000-08:00

The San Francisco Perl Mongers are sponsoring a demo of three Perl IDE's on Tuesday, February 28, 2006:

Emacs - Joe Brenner will show Emacs with perlnow.el.
EPIC/Eclipse - I'll be doing this demo. (See my article on why Perl Needs Better Tools)
Komodo - Josh Berkus is showing ActiveState's Komodo (works on Linux, OS X and Windows)

When & Where:
When: Tuesday, February 28, 2006, 8:00 p.m.
Where: Perpetual Entertainment, Fifth floor;
149 New Montgomery Street, San Francisco, CA
RSVP: qw@sf.pm.org - please let us know if you are attending, and if you want thai food, bring some $$

If you would like to attend, please contact Quinn Weaver at the address above - and bring cash if you want Thai food!

Lets Make A Deal Game Theory

2006-02-12T09:34:00.000-08:00

(originally posted 10:08 AM, Feb 11, 2006)

A couple days ago (yes, in a bar) I became intrigued with a fairly well known game problem, here's my version:

There are three doors, one of which is a winner.
You pick one door, but it isn't opened yet.
At this point at least one of the unpicked doors (maybe both) are losers.
A losing unpicked door is opened.
You now have the option of either sticking with your original choice, or switching to the remaining unopened door. Which has a better chance of being the winner?

Here is a Perl script I wrote which will play the game using both the "switch" and "stay" strategies: http://eigenstate.net/misc_scripts/make_a_deal.pl

Unit tests for Mozilla / Firefox coming soon

2006-02-09T08:52:00.000-08:00

Dave Liebreich of Mozilla.com has posted the source code for jssh-driver - a unit test framework for use in Mozilla browsers, (e.g. Firefox). This little framework will allow you to have a directory of HTML files, and test if the browser renders them correctly. Basically the test loads the "golden master" versions into the browser and compares the rendered version to the version on disk. (When the browser renders an HTML page it takes it apart and puts it back together - hopefully correctly.)

US Internet biz profits from oppression

2006-02-02T08:44:00.000-08:00

From the Washington Post:

House: Internet Companies Give in to China

By FOSTER KLUG
The Associated Press
Wednesday, February 1, 2006; 10:37 PM

WASHINGTON -- Lawmakers on Wednesday accused U.S.-based Internet companies of
giving in to pressure from China and helping to censor Web users in violation
of American principles of free speech.

I think it's disgusting that these companies are seeking to profit from cooperation with oppression while simultaneously benefiting from the freedoms afforded them here in the US.

More tests, fewer bugs

2006-02-01T08:36:00.000-08:00

Mozilla is looking for a few good test-driven engineers...

I visited the Mozilla Corporation offices yesterday, at the invitation of Dave Liebreich, who is heading up the effort to bring more testing to the Mozilla code base. There is a wiki page: http://wiki.mozilla.org/SoftwareTesting describing some projects and ideas. Dave is a good guy doing good work - let's help!

Concrete Canvas

2006-01-31T08:04:00.000-08:00

http://www.concretecanvas.org.uk/

Instant semi-permanent structure.
Fill bag with water, activate chemical gas-pack, it inflates and hardens and is ready for use in 12-hours.

Update (1 Feb 2006):
My friend and architect Bob Theis (http://www.bobtheis.net/) raised these important issues:

Clever idea. Two reactions:

1. Hard to imagine a shell that thin being dimensionally stable enough for such a span in compression ( how does it resist local buckling? ). ESPECIALLY when you cover it with earth to gain some insulation ( see below ).

2. The plastic sheet interior would condense ALL the water vapor that hits it when the temperature outside is low ( despite the website claims, the insulation value of the skin should be next to nil ), where it would then freeze in colder situations. So insulation and ventilation would be serious habitability issues.

Adding Assertions in Perl

2006-01-14T16:10:00.000-08:00

I've been working on a Perl module that provides a set of assertion methods that will work in Perl 5.6.1 or later. (Note that Perl 5.10 should have some form of builtin support for assertions.)

So far I've implemented:


assert( expr, $optional_message );  # passes if expr is true
assert_is($$this,$that, $opt_msg); # compare with eq
assert_isnt($this,$that, $opt$msg); # Compare with ne

# all values must be == to each other
assert_num_equals($arrayref, $opt_msg);

save_data($key, $ref_to_data); # saves clone of data

# Assert that some data has (or not) the same values as the
# previsouly saved data - does a deep compare.

assert_data_not_different($key,$ref_to_data, $opt_msg);

assert_data_different($key,$ref_to_data, $opt_msg);

I've also implemented methods to set the pass and fail behaviors:


set_pass_behavior('silence');
set_pass_behavior('warn');
set_pass_behavior( \&my_sub ); # CODE ref


set_fail_behavior('silence');
set_fail_behavior('warn');
set_fail_behavior('confess'); #die with stack trace
set_fail_behavior( \&my_sub ); # CODE ref

I'm doing this for a client and am not sure if we'll be allowed to release the code publicly, but I hope so.

Adding Unit Tests to Legacy Code

2006-01-07T08:46:00.000-08:00

I've started adding Unit Tests to a "legacy" code library. So far, the basic approach I am taking is:

Create the test harness.
The first test is to compile the old code library. Of course that fails at first because of all the things the library depends on.
Create enough "fake" class files that the library compiles.
Pick one subroutine (method) to test, and add a test that runs that subroutine. Of course it fails because of all the missing dependencies - the subroutine under test uses a bunch of subroutines defined in others.
In the test suite, create a FakeMethods class that defines stub versions of the missing external methods/subroutines, for example, the subroutine I am testing calls GetTotalAmount($cost,@items) so in the test suite I have something like this:
```
sub GetTotalAmount {
 cluck('fake sub called');  # Print a stack trace showing we were called
 my($cost,@items) = @_;     # Document the arguments expected
 return;                    # Return nothing for now
}
```

Some of the fake subroutines will need to return some actual values for the subroutine I am testing to run. Add just enough input so the test passes, even when this seems ridiculous. For example, I found that one subroutine wanted the name of a file to open, and that the subroutine would run even if I passed in the name of a non-existent file. OK, that's what I did. Later, we can add a test expecting the subroutine to throw an exception if the file doesn't exist, and then add defensive code to throw the subroutine.
Continue repeating steps 5 and 6 until the subroutine I am testing runs without throwing an exception.
Add tests to run the subroutine with variations on its arguments and/or environment. I may need to add more fake subroutines, mock data, etc.
The result is that I have a pretty clearly documented view of what the subroutine/method actually requires to run as of today.

Semco and Ricardo Semler - Agile Industry?

2005-12-30T22:41:00.000-08:00

Some Semco links:

CNN, 2004:
http://edition.cnn.com/2004/BUSINESS/05/19/go.semlar.transcript/

Excerpt from Semler's 2004 book "The Seven-Day Weekend"
http://www.nfib.com/object/4243663.html

Wikipedia entry on Ricardo Semler:
http://en.wikipedia.org/wiki/Ricardo_Semler

An excellent interview with Semler by CIO Insight, unfortunately dated April 1, 2004:
http://www.cioinsight.com/print_article2/0,1217,a=124700,00.asp
Very good stuff about corporate email privacy, among other issues, here's an excerpt from Semler:

...we searched far and wide for anybody who could tell us what kind of software or system could be installed on our [server] that would make it impossible for our own IT people to spy on people's e-mail. We did not find one. We had to customize one.

Working Effectively With Legacy Code

2005-12-23T09:33:00.000-08:00

I'm preparing for a new contract (with Barclays Global Investors) where I'll be helping to improve a software developemnt process in a group that has many years of existing code, so I've been reading Michael Feathers new book "Working Effectively with Legacy Code" (http://my.safaribooksonline.com/0131177052).

So far, I really like the book - it quite modern, coming from an agile/XP approach and consistently emphasizes that the basic task is to get the legacy code under a test harness, so that changes can be made with fewer ulcers.

The book goes into many different examples of how existing code is resistant to being testable, and then shows (usually two or more) approaches for overcoming or workign around those problems.

Another reason I like that the book is that Feathers consistently emphasizes how hard this is - no magic solutions, ugly compromises often required, etc. but that you can make big progess out of many small steps.

Unit Testing in Perl with Test::Unit

2005-11-27T09:40:00.000-08:00

I've come to prefer Test::Unit over Test::More. The main reason is that in Test::Unit you define each test as a separate subroutine, so the variables used for one test cannot pollute another test.

Test::More is a widely used module for Unit Tests in Perl. With Test::More your tests look like this:

# Test method_a()
my $expected_1 = 23 * $CONSTANT; # some value we expect;
is( $expected_1, $object->method_a(23),
   "method_a(23) returned expected value.");

my $expected_2 = 17 * $CONSTANT; # A new expected value
is( $expected_2, $object->method_a(17),
   "method_a(17) returned expected value");

# Test another_method()
my $expected_3 = _get_favorite_color();
is( $expected_3, $object->another_method('favorite'),
   "another_method('favorite') returned proper color.");

my $expected_4 = _get_recent_color();
is( $expected_4 $object->another_method('recent'),
   "another_method('recent') returned proper color.");

See how we need to come up with many versions of the $expected variable?

We could also just reuse it, but that can cause trouble if there are many tests and you forget to reset it.

It is better practice to use a different variable name for each test, but in many situations there are a couple dozen tests in that one file where it makes sense to use the same basic variable name for many different tests. That could lead to variable names like $expected_100. Also, there is always the risk that some temporary variables used for one test end up "polluting" a later test where the programmer didn't realize a variable was already defined earlier in the file.

The best solution is to isolate the code for each test, or small group of related tests into their own block, so that temporary variables for one test cannot interfere with another test or tests.

In Test::Unit each test is a subroutine, which can contain any number of assertions - so all the temporary variables and other setup for a particular group of tests are kept isolated from all the other tests. In addition, if you provide a subroutine called set_up() it is automatically called before running each test subroutine, and likewise, tear_down() is called after each test, this is useful for populating objects and test data structures, so that each test gets a clean set of test data to work with.

In Test::Unit the tests above might look like this:

sub test_method_a {
my $self = shift;

my $expected_1 = 23 * $CONSTANT; # some value we expect;
$self->assert_equals( $expected_1, $object->method_a(23));

my $expected_2 = 17 * $CONSTANT;
$self->assert_equals( $expected_2, $object->method_a(17));
}

sub test_another_method {
my $self = shift;

my $expected_1 = _get_favorite_color();
$self->assert_equals($expected_1, $object->another_method('favorite'));

my $expected_2 = _get_recent_color();
$self->assert_equals($expected_2, $object->another_method('recent'));
}

Test::Unit provides a bunch of assertion methods:

assert_equals / assert_not_equals: Tries to guess what kind of comparison to make. Usually works fine. If the first argument (the 'expected') is an object it checks if the == operator has been overloaded and will use it if so.
assert_num_equals,assert_num_not_equals,assert_str_equals,assert_str_equals: Force numeric/string comparison.
assert_matches(qr/PATTERN/, STRING, [, MESSAGE]), assert_not_matches: Assert that the regular expression matches.
assert_deep_equals(expected_ref, ref_to_test [, MESSAGE ]): Used to compare complex data strucrtures, like hashes of arrays of hashes. Assert that the the data pointed to by ref_to_test matches the data structure pointed to by expected_ref

Perl Best Practices

2005-11-04T19:20:00.000-08:00

Damian Conway's new book, Perl Best Practices is a very good, thought provoking, and useful addition to any Perl programmer's collection.

From my point of view, the best thing about the book is that it provides a lot of food for thought - even if one disagrees with particular recommendations I think all the suggestions in the book areworth thinking about, and I am certain almost any reader will discover improvements they can make in their code and approaching to coding.

Tags: perl, perl

vi cheat sheets

2005-10-27T09:39:00.000-07:00

Was going to email this list of vi cheat-sheets to a co-worker, but I'll post instead:

http://www.kcomputing.com/vi.html
http://cac.uvi.edu/miscfaq/vi-cheat.html
http://ase.tufts.edu/mechanical/compstudio/help/vihelp.html

(that list is from page 164 of my book.... :-)

PHP Comes to Eclipse

2005-10-23T21:12:00.000-07:00

Martin Brown blogged about PHP coming to the Eclipse platform (back on Oct. 18th.) This interests me because I find that Eclipse currently is the best cross-platform IDE for Perl, a language I like very much. (See my article at perl.com, "Perl Needs Better Tools")

Wargaming - another way of modeling the universe

2005-10-23T09:45:00.000-07:00

I found a reference to myself in Kevin Trainor's blog, Wombat Rampant. The posting is about the decline of paper-based combat simulation games. Back in the 1970's I used to design and play wargames, which to me, are part of my lifelong involvement with building things.

Take Control of Permissions in Mac OS X

2005-10-22T09:15:00.000-07:00

My long-time friend and colleague Brian Tanaka has written a new eBook "Take Control of Permissions in Mac OS X" that provides a bunch of help for the average Mac user in dealing with the often mysterious subject of "permissions" and "ownership" of files and folders in Mac OS X.

Permissions and ownership of files and folders are a tough subject.

Part of the reason, I think, is that there isn't a really good physical-world analogy - objects in the physical world don't have -rwxr-xr-x attached to them, so it's a pretty alien concept - in the physical world, if you can touch it you can write on it, now maybe you shouldn't write on it, because of laws, social custom, etc. but there are no attached permission settings, and no operating system to enforce permissions. Ownership is an easier concept for people to grasp, because of the extensive real-world analogs.

Brians' eBook is a good, searchable, handy guide to dealing with these issues, and it's only ten bucks. You do not need to know, or care about Unix to benefit from his guide, and even experienced users will find stuff they didn't know - for example what "Repair Permissions" and "Ignore Ownership" actually do.

If you want to really dive into learning the Unix layer of Mac OS X, and can handle a higher price-tag, and dealing with a paper book, then I recommend my book (shameless plug, I know) "Unix for Mac OS X Tiger", but to focus on just Permissions and Ownership, Brians' book is a fine place to start.

How to estimate memory usage for a large hash?

2005-10-12T21:14:00.000-07:00

I had a conversation recently about how to estimate the size of storage for hash keys when processing a huge data set.

Let's say you are gonna process 100,000,000 name/value pairs and you want to estimate how much memory is needed to store the list of unique names - is there a current "best practice" for this?

Problems with log files and daemontools

2005-10-12T21:10:00.000-07:00

Daemontools is a software suite for Unix that makes it easy to run any program or script as a daemon.

I recently ran into an interesting problem with daemontools - none of the STDOUT output from my daemon was showing up in the log file.

It turns out that your daemon must use unbuffered STDOUT or it won't go into the log file. In my case the daemon is a Perl script so I added automatic flushing of output buffers to the script, and it works. That means I added this:

$| =1;

to the Perl script.

Unix for Mac OS X Tiger - book released

2005-09-24T08:46:00.000-07:00

My book "Unix for Mac OS X" is now out in a new edition, completely revised for OS X 10.4 (Tiger).

This book is a very complete beginner's guide to Unix. The book assumes no prior Unix experience and yet provides more detail than any other beginning Unix book of which I am aware. In my not-so-humble-opinion the book is probably the best beginners guide to Unix on the market.

The book is over 500 pages and provide great detail on the Unix layer of Mac OS X (aka Darwin.)

The book teaches you how to get to the command line, to edit files using a command line editor, to deal with Unix permissions (an entire chapter on that), and so on. I'll post a table of contents in a later posting.

Buying it:

Unit Testing in Perl

2005-09-17T12:16:00.000-07:00

I've been using the Test::Unit module for creating unit tests and I like it.

The most common Perl module for creating Unit Tests is probably Test::More. For me, there are two important advantages to Test::Unit

1. In Test::Unit each test is actually a subroutine, so the variables etc. you create for one test are isolated from those created for other tests.

2. Test::Unit automatically runs a method called setup() before each test,a nd teardown() after each test, which is useful for things like populating a test database, etc.

Perl Needs Better Tools

2005-08-26T07:19:00.000-07:00

My article on better tools for Perl just came out on Perl.com:

http://www.perl.com/pub/a/2005/08/25/tools.html

I describe many of the features available in modern Integrated Development Environments (IDE) and talk about what a good Perl IDE should have.

I'll be able to respond to comment there and here for the next dayt or so, then I'll be offline for over a week.

Unix commands unique to Darwin/OS X

2005-08-07T18:25:00.000-07:00

I'm in the process of finishing the revised edition of my book, "Unix for Mac OS X" to cover OS X 10.4, Tiger), and am hoping to include a list of Unix commands that appear pretty much only in Darwin/OSX. Here's a pre-release version of the list:

http://www.matisse.net/OSX/darwin_commands.html

Dispatches from Blogistan - a travel guide in the making.http://www.blogger.com/img/gl.link.gif

2005-08-07T12:15:00.000-07:00

Long-time friend Suzanne Stefanac is on the case at http://www.dispatchesfromblogistan.com/ creating a new book for Peachpit Press.

Given Suzanne's experience with media and facility with people, this should be a friendly, intelligent and insightful work. I hear she is going to include a chapter on Good Writing, something we could all use some help with.

Ruby-on-Rails looking interesting

2005-08-01T20:54:00.000-07:00

OK, I admit the momentum is getting to me.
I started looking into Ruby several years ago, but never built anything with it.

Now, thing like this post showing how little code can be needed are making me itch to try again.

Progress on Perl tools Article

2005-07-31T22:48:00.000-07:00

I finally finished a complete first draft of my article for Perl.com on better development tools for Perl. It's been sent off to chromatic at O'Reilly and hopefully I'll hear back soon.

VIP - New Perl Editor Project

2005-07-31T09:07:00.000-07:00

Kaare Rasmussen told me about a new CPAN project led by Nadim Ibn Hamouda El Khemir called VIP:

The goal of the VIP project is to produce a first class Perl editor that
can be used as a component in a (yet to be developed) IDE. We will try
to write vip so it will build on the strong points of of Perl 5 and 6.

Our first step is to provide the editor itself. It will consist of the
core engine and have (at first) three interfaces; used from Perl itself,
a text based (curses) and a graphic (gtk) interface.

Apart from the usual features, such as syntax coloring and
templates/wizards, we plan to include innovative features, like support
for Pair Programming, and to make it extremely configurable and
pluggable (integration with Sprog (http://sprog.sourceforge.net/) will
be one way to extend Vip).

The project is currently in the initial phase and we expect to have a
working draft within the next couple of months.

We can always use help. To test it out, find bugs, propose features and
write documentation, plugins and code.

The project has a name on CPAN:
http://search.cpan.org/~nkh/Text-Editor-Vip-0.011/, a home page
(http://...) and a discussion forum (http://www.cpanforum.org/...).

Perl
IDE

Problem installing MySQL 4.1.13 on Mac OS X 10.4.2

2005-07-31T08:48:00.000-07:00

Bug report filed with MySQL: http://bugs.mysql.com/bug.php?id=12288

Here's the bug description:

Trying to compile MySQL 4.1.13 on Mac OS X 10.4.2
gcc_select show gcc 4.0.0:
$ gcc_select
Current default compiler:
gcc version 4.0.0 20041026 (Apple Computer, Inc. build 4061)

$ locate gcc_s
/usr/lib/gcc/powerpc-apple-darwin8/4.0.0/libgcc_s.dylib
/usr/lib/gcc/powerpc-apple-darwin8/4.0.0/libgcc_static.a
/usr/lib/gcc/powerpc-apple-darwin8/4.0.0/libgcc_s_ppc64.dylib
/usr/sbin/gcc_select
/usr/share/man/man8/gcc_select.8


The build fails with:
...
Making all in sql
if g++ -DMYSQL_SERVER -DDEFAULT_MYSQL_HOME="\"/usr/local/mysql\""
-DDATADIR="\"/usr/local/mysql/var\""
-DSHAREDIR="\"/usr/local/mysql/share/mysql\"" -DHAVE_CONFIG_H -I. -I. -I..
-I../innobase/include -I../include -I../include -I../regex -I.     -O3
-DDBUG_OFF    -fno-implicit-templates -fno-exceptions -fno-rtti
-DHAVE_DARWIN_THREADS -D_P1003_1B_VISIBLE -DSIGNAL_WITH_VIO_CLOSE
-DSIGNALS_DONT_BREAK_READ -DIGNORE_SIGHUP_SIGQUIT -MT gen_lex_hash.o -MD -MP -MF
".deps/gen_lex_hash.Tpo" -c -o gen_lex_hash.o gen_lex_hash.cc; then mv -f ".deps/gen_lex_hash.Tpo" ".deps/gen_lex_hash.Po"; else rm -f
".deps/gen_lex_hash.Tpo"; exit 1; fi
/bin/sh ../libtool --preserve-dup-deps --mode=link g++  -O3 -DDBUG_OFF
-fno-implicit-templates -fno-exceptions -fno-rtti -DHAVE_DARWIN_THREADS
-D_P1003_1B_VISIBLE -DSIGNAL_WITH_VIO_CLOSE -DSIGNALS_DONT_BREAK_READ
-DIGNORE_SIGHUP_SIGQUIT   -o gen_lex_hash  gen_lex_hash.o ../myisam/libmyisam.a
../myisammrg/libmyisammrg.a ../heap/libheap.a ../vio/libvio.a
../mysys/libmysys.a ../dbug/libdbug.a ../regex/libregex.a
../strings/libmystrings.a -lz   -lm
mkdir .libs
g++ -O3 -DDBUG_OFF -fno-implicit-templates -fno-exceptions -fno-rtti
-DHAVE_DARWIN_THREADS -D_P1003_1B_VISIBLE -DSIGNAL_WITH_VIO_CLOSE
-DSIGNALS_DONT_BREAK_READ -DIGNORE_SIGHUP_SIGQUIT -o gen_lex_hash gen_lex_hash.o
-Wl,-bind_at_load  ../myisam/libmyisam.a ../myisammrg/libmyisammrg.a
../heap/libheap.a ../vio/libvio.a ../mysys/libmysys.a ../dbug/libdbug.a
../regex/libregex.a ../strings/libmystrings.a -lz -lm
/usr/bin/ld: can't locate file for: -lgcc_s
collect2: ld returned 1 exit status
make[2]: *** [gen_lex_hash] Error 1
make[1]: *** [all-recursive] Error 1
make: *** [all] Error 2

How to repeat:
Use source distribution mysql-4.1.13.tar.gz

$ tar xfvz mysql-4.1.13.tar.gz
$ cd mysql-4.1.13
$ ./configure --prefix=/usr/local/mysql
$ make

Build fails.

Suggested fix:
None known yet.

mysql macosx

Access Control Lists (ACLs) in Mac OS X

2005-07-11T09:11:00.000-07:00

Powerful but complex, and hard to understand.

chmod +a "dancers allow list,directory_inherit" dropbox

should allow anyone in group dancers to list the contents of dropbox and any subdirectories, but the inheritence doesn't seem to happen.

New refactoring book in the works?

2005-07-09T11:14:00.000-07:00

I heard from a reliable source yesterday that O'Reilly is considering doing a book on Refactoring. Maybe they'll include Perl in it.

Perl IDE's

2005-06-25T23:14:00.000-07:00

Two of the most sophisticated graphical Integrated Development Environments (IDE) for Perl are probably EPIC and Komodo.

Two command-line IDE's are emacs and vi/vim. There are a variety of extensions that people have created for these two venerable text editors that provide many of the capabilities of graphical IDE's.

Better Development Tools for Perl, or Perl is Dead

2005-06-25T22:53:00.000-07:00

I'm working on an article for O'Reilly's perl.com wherein I assert that what Perl needs is few great Integrated Development Environments that equal or exceed the features currently available for Java.

An early rough set of notes on the subject is online at http://www.eigenstate.net/perl_tools/

The fully developed article should be on perl.com in a month or two.

A related an valuable article is Adam Kennedy's article on his new PPI module.