Two Alpha

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-21T22:17:00.000-08:00

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

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.