Projects that I’ve been involved with.

Mapping Engineering Practices to Agile Principles

Sat, 8 Oct 2011 11:27:36 +0200

I’ve done this exercise a number of times with various organization in transition to some form of Agile - Scrum, XP, Kanban, etc. It works well at the developer level and also at the executive level (although they don’t really understand the engineering practices as well as they want to appear to know them).

Mapping Practices to Principles.pdf

A quick facilitation guide is on the last page - it will help you facilitate this exercise with your group.

Definition of Done Exercise

Sat, 1 Oct 2011 00:05:36 +0200

Assuming you are on a Scrum/Agile software development team, then one of the first 'working agreements' you have created with your team is a 'Definition of Done' - right?
Oh - you don't have a definition of what aspects a user story that is done will exhibit. Well then, you need to create a list of attributes of a done story. One way to do this would be to Google 'definition of done' ... here let me do that for you: http://tinyurl.com/3br9o6n. Then you could just use someone else's definition - there DONE!
But that would be cheating - right? It is not the artifact the list of done criteria that is important for your team - it is the act of doing it for themselves, it is that shared understanding of having a debate over some of the gray areas that create a true working agreement. If some of the team believes that a story being done means that there can be no bugs found in the code - but some believe that there can be some minor issues - well, then you have a great point to have a team discussion. Better at the beginning of the project, rather than right before the boss says 'ship it'. If you are having this dialogue (more than a debate/discussion - everyone is explaining their assumptions and exposing their values underlying their position in dialogue) then your team has entered the 2nd stage of team formation (Forming, Storming, Norming, Preforming) - congratulations! Now there is the second reason to create a definition of done - it moves the team along the continuum of strangers to team-mates.
So rather than using someone else's list you want to create your own. Yes, sometimes you need a little water to prime the pump. Or you could get the energy flowing in the meeting with an exercise to get people out of their seats (you increase blood flow to the brain by 20% just by standing up) and up at the white board and interacting with each other. Try drawing a target (very large) - 3 concentric circles (or rectangles) on the board, label the inner most 'Now', the outer 'Later' and the middle 'Next'. That is a form of prioritization (now -> next -> later) that you want your team to become very familiar with (we use it in backlog ordering - right?). Then place stickies or index cards on the table and have someone write just one aspect of the definition of done on a card/sticky, then place it on the board in the proper location. Take turns, the next person may either - move the card to a 'better' location (now, next, later) or create a new card and post it. Play continues until we exhaust the fun in the game, or get good enough. You might want to dialogue on the aspect of growing your definition of done over time. One could easily imagine that done means something different in sprint one than it does for sprint 73 after four releases and lots of customer feedback, now that you have continuous deployment working.
If you want some cheater index cards then use mine - they are no better than anyone else's answer to a team question, but these might get a reluctant team up and interacting in the game of collaboration.
Definition of Done Exercise.pdf
Definition of Ready Exercise.pdf
Definition of Done & Definition of Ready Exercise - Facilitators Guide.pdf

Pair Chess Game Exercise

Sun, 20 Feb 2011 00:42:32 +0100

Some years ago I designed this exercise for a Pair Programming simulation using the media of the game of chess. The idea was to have a pair on each side of the board, they would work together to finish a famous game against their opponents (a pair also).
I never used the exercise because the developers I was working with didn't know the game of chess, and didn't seem interested in the simulation. If you use this please let me know how it works out.

Game 1 (after 31 ... Bxa2) Garry Kasparov (White) vs X3D Fritz Computer (Black) Man-Machine World Chess Championship 2003

Chess Game Pairing Exercise Instructor.PDF

Download the PDF for more instructions.

iTelephoto 100-400mm f/4.5-5.6 L IS Zoom Lens for iPhone

Tue, 11 Aug 2009 00:09:49 +0200

I’ve been taking all my pictures with this new lens & camera combination for the iPhone. The image quality is great from edge to edge and the telephoto zoom allows image reach from Illahee to Ketchikan.

iDuct Systems EF mounting hardware

The Canon 100 - 400 F IS zoom lens is mounted to the iPhone with iDuct Systems custom hardware ($8.97 at Ace Hardware).

Canon 100-400mm f/4.5-5.6L IS
L-series super telephoto zoom lens equipped with an Image Stabilizer. The fluorite and Super UD-glass elements largely eliminate secondary spectrum. The floating system also ensures high picture quality at all focal lengths. The Image Stabilizer has two modes and it is compatible with Extenders 1.4x II and 2x II.

OverpunchFormat - Java class

Mon, 14 Apr 2008 07:34:34 +0200

OverpunchFormat is a subclass of DecimalFormat that formats decimal numbers into NSF Overpunch Format.
The purpose of an Overpunch format is to encode the sign (+/-) into the least significant (right-most) digit via an encoding scheme. Also the values are typically dollar amounts, and therefore are integers representing cents (1/100 dollar). The use of DecimalFormat's setMultipler method will make quick work of this scaling.

Get the Java source code for OverpunchFormat.java.

OverpunchFormat is a subclass of DecimalFormat that formats decimal numbers into NSF Overpunch Format.

The purpose of an Overpunch format is to encode the sign (+/-) into the least significant (right-most) digit via an encoding scheme. Also the values are typically dollar amounts, and therefore are integers representing cents (1/100 dollar). The use of DecimalFormat's setMultipler method will make quick work of this scaling.

//package name.koontz.util;

import java.io.Serializable;
import java.text.NumberFormat;
import java.text.ParsePosition;
import java.text.FieldPosition;
//import java.lang.Number;
//import java.lang.StringBuffer;
import java.text.*;

/**
* OverpunchFormat is a subclass of DecimalFormat that formats
* decimal numbers into NSF Overpunch Format.
* 
* The purpose of an Overpunch format is to encode the sign (+/-) into the
* least significant (right-most) digit via an encoding scheme. Also the values are
* typically dollar amounts, and therefore are integers representing cents
* (1/100 dollar). The use of the setMultipler method will make quick work of
* this scaling.
* 
* <Blockquote>
* 
* Holy hanging chad! Batman, the bat computer has detected an
* overpunched field, what could it mean?
* 
* Well, Robin, it means the Joker has saved a byte in transmition cost, but it
* will take the bat computer only 23 instructions to figure out what this sign
* could be...
* 
* </Blockquote>
* 
* 
* OverpunchFormat does not support locales, itself! So do not expect Kanji
* characters in your overpunched output.
* 
*
* <h3>Overpunch Encoding</h3>
* <pre>
* Least
* Significant Positive Negative
* Digit Overpunch Overpunch
* 0 { }
* 1 A J
* 2 B K
* 3 C L
* 4 D M
* 5 E N
* 6 F O
* 7 G P
* 8 H Q
* 9 J R
*
* </pre>
*
* Example: 
* <blockquote>
* -1575 => 157N 
* +1200 => 120{ 
* </blockquote>
* 
*
* If OverpunchFormat.parse(String, ParsePosition) fails to parse a string, it
* returns null, leaves the ParsePosition index unchanged, and sets the
* ParsePosition error index.
* 
* A OverpunchFormat pattern contains only a postive pattern (no negative subpattern).
* Since the whole concept of an overpunched value is to
* encode the sign within the last digit, there will be no negative subpattern.
*
* 
* Note: DecimalFormat JVM 1.2.2 bugs Sun Bug Id 4322804, 4254220, 4243108 
*
*
* @see Format
* @see NumberFormat
* @see DecimalFormat
* @see ParsePosition
*/
public class OverpunchFormat extends java.text.DecimalFormat
implements Cloneable, Serializable {

// array of overpunch replacement characters
private static final char[] positiveDigit = {'{', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'};
// overpunch digit 0 1 2 3 4 5 6 7 8 9
private static final char[] negativeDigit = {'}', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R'};

public OverpunchFormat() {
super();
}

public OverpunchFormat(String pattern) throws IllegalArgumentException {
super(pattern);
//
}

/**
* Returns an instance of Number with a value matching the given string.
*
*
* @param text the string to be parsed
* @param parsePosition on entry, where to begin parsing; on exit, just past the last parsed character. If parsing fails, the index will not move and the error index will be set.
* @return the parsed value, or null if the parse fails
*/
public Number parse(String text, ParsePosition parsePosition) {
//
int sign = 1; // or -1 if negative
char lastDigit;
char overpunchChar = '{';
int overpunchIndex = 0;

// start at the parsePosition within text - look for a non-numeric char
// that's the overpunch char
if ( parsePosition.getIndex() < text.length() ) {
for (int i = parsePosition.getIndex(); i < text.length(); i++) {
char c = text.charAt(i);
if ( Character.getType(c) == Character.DECIMAL_DIGIT_NUMBER ) {
continue;
} else {
// found first non digit char - that's the overpunch
overpunchChar = c;
overpunchIndex = i;
break;
}
}
}

// reverse the overpunch

switch (overpunchChar) {
case '}':
sign = -1;
lastDigit = '0';
break;
case '{':
sign = 1;
lastDigit = '0';
break;
case 'A':
sign = 1;
lastDigit = '1';
break;
case 'B':
sign = 1;
lastDigit = '2';
break;
case 'C':
sign = 1;
lastDigit = '3';
break;
case 'D':
sign = 1;
lastDigit = '4';
break;
case 'E':
sign = 1;
lastDigit = '5';
break;
case 'F':
sign = 1;
lastDigit = '6';
break;
case 'G':
sign = 1;
lastDigit = '7';
break;
case 'H':
sign = 1;
lastDigit = '8';
break;
case 'I':
sign = 1;
lastDigit = '9';
break;
case 'J':
sign = -1;
lastDigit = '1';
break;
case 'K':
sign = -1;
lastDigit = '2';
break;
case 'L':
sign = -1;
lastDigit = '3';
break;
case 'M':
sign = -1;
lastDigit = '4';
break;
case 'N':
sign = -1;
lastDigit = '5';
break;
case 'O':
sign = -1;
lastDigit = '6';
break;
case 'P':
sign = -1;
lastDigit = '7';
break;
case 'Q':
sign = -1;
lastDigit = '8';
break;
case 'R':
sign = -1;
lastDigit = '9';
break;
default:
// not the overpunch char - error
parsePosition.setErrorIndex(overpunchIndex);
return null; // error return null

}

// replace with the overpunch char in text with the digit
StringBuffer sb = new StringBuffer(text);

sb.setCharAt(overpunchIndex, lastDigit);

// now call the super's function
Number n = super.parse(sb.toString(), parsePosition);

if ( n instanceof Double ) {
double d = n.doubleValue();
d = d * sign;
n = new Double(d);
} else if ( n instanceof Long ) {
long l = n.longValue();
l = l * sign;
n = new Long(l);
} else {
; // nothing
}

return n;
}

/**
* Formats a long to produce a string.
*
* @param number the long to format
* @param result where the text is to be appended
* @param fieldPosition On input: an alignment field, if desired. On output: the offsets of the alignment field.
* @return The value passed in as the result parameter
*/
public StringBuffer format(long number, StringBuffer result, FieldPosition fieldPosition) {
//System.out.println("OverpunchFormat.format|long number");
//System.out.println("OverpunchFormat.format( "+number+", "+result.toString()+", "+fieldPosition+" )");
//
StringBuffer buf = new StringBuffer(result.length()+20);
long abs = Math.abs(number); // get the absolute value
//System.out.println(" abs = "+abs);

// call DecmialFormat to format all but the overpunch
buf = super.format(abs, result, fieldPosition);
//System.out.println(" super.format() returns buf = " + buf.toString());
// now we must workout the overpunch
//
// get last digit of the string
char overpunchChar = buf.charAt(buf.length()-1);
//System.out.println(" buf.length()-1 = " + (buf.length()-1));
//System.out.println(" overpunchChar = " + overpunchChar);
// convert last digit to index into the overpunch (+/-) array
int overpunchIndex = Character.getNumericValue(overpunchChar);
//System.out.println(" overpunchIndex = " + overpunchIndex);
// get overpunch char
if ( number < 0 ) {
overpunchChar = negativeDigit[overpunchIndex];
} else {
overpunchChar = positiveDigit[overpunchIndex];
}
//System.out.println(" overpunchChar = " + overpunchChar);
// replace the lastChar in the string with new lastChar
buf.deleteCharAt(buf.length()-1);
buf.append(overpunchChar);
//System.out.println(" buf = " + buf.toString());

return buf;
}

/**
* Formats a double to produce a string.
*
* @param number the double to format
* @param result where the text is to be appended
* @param fieldPosition On input: an alignment field, if desired. On output: the offsets of the alignment field.
* @return The value passed in as the result parameter
*/
public StringBuffer format(double number, StringBuffer result, FieldPosition fieldPosition) {
//System.out.println("OverpunchFormat.format|double number");
//System.out.println("OverpunchFormat.format( "+number+", "+result.toString()+", "+fieldPosition+" )");
//
StringBuffer buf = new StringBuffer(result.length()+20);
double abs = Math.abs(number); // get the absolute value
//System.out.println(" abs = "+abs);

// call DecmialFormat to format all but the overpunch
buf = super.format(abs, result, fieldPosition);
//System.out.println(" super.format() returns buf = " + buf.toString());

// now we must workout the overpunch
//
// get last digit of the string
char overpunchChar = buf.charAt(buf.length()-1);
//System.out.println(" buf.length()-1 = " + (buf.length()-1));
//System.out.println(" overpunchChar = " + overpunchChar);

// convert last digit to index into the overpunch (+/-) array
int overpunchIndex = Character.getNumericValue(overpunchChar);
//System.out.println(" overpunchIndex = " + overpunchIndex);

// get overpunch char
if ( number < 0 ) {
overpunchChar = negativeDigit[overpunchIndex];
} else {
overpunchChar = positiveDigit[overpunchIndex];
}
//System.out.println(" overpunchChar = " + overpunchChar);

// replace the lastChar in the string with new lastChar
buf.deleteCharAt(buf.length()-1);
buf.append(overpunchChar);
//System.out.println(" buf = " + buf.toString());

return buf;
}

/**
* The main program for the class - a test method.
*
*@param args the text to parse
*/
public static void main(String[] args) {

OverpunchFormat of = new OverpunchFormat();
of.applyPattern("0000000"); // fixed field zero padded
of.setMultiplier(100); // imply 2 decimal places

if (args.length < 2) {
System.out.println("Usage: java OverpunchFormat 'pattern' 'value'");
System.out.println("Examples format():");
System.out.println(" 9876 -> " +of.format(9876l));
System.out.println(" -1.35 -> " +of.format(-1.35));
System.out.println(" .2389 -> " +of.format(0.2389));
System.out.println("note; fixed field zero padding, implied decimal place, rounding and encoding");

StringBuffer sb = new StringBuffer("x=012345F dollars ");
ParsePosition pos = new ParsePosition(2);
System.out.println("Examples parse():");
System.out.println(" before call:" + sb);
System.out.println(" parse(sb, pos) where pos =" + pos);
System.out.println(" parse returns a Number = " + of.parse(sb.toString(), pos));
System.out.println(" and sets ParsePosition.index = " + pos.getIndex() + " & errorIndex = " + pos.getErrorIndex());

System.exit(99);
} else {
StringBuffer sb = new StringBuffer("OverpunchFormat of "+ args[1] +" is ");
of.applyPattern(args[0]);
of.format(Double.valueOf(args[1]), sb, new FieldPosition(NumberFormat.FRACTION_FIELD) );

System.out.println(sb.toString());

}

}

}

SequentialExtension - Java class

Mon, 14 Apr 2008 07:21:33 +0200

SequentialExtension is a Java class to create filenames with a sequential extension. Given a directory with file.001, file.002, file.005; what is the next sequential filename? Either file.003 or file.006 - this utility class will return either java.io.File based on your desire for infix mode (file.003) or not (file.006).

Get the Java source code for SequentialExtension.java.

A utility class for generating sequential file extensions.

Assume a directory with:

|- file.name.001
|- file.name.002
|- file.name.005

What is the next file name in the sequential set?
file.name.006 or maybe file.name.003
Depends on what you want to do.

The method nextSequentialFile will generate a File object to meet either need.

/*
* Copyright (c) 2003 David A. Koontz
* Licensed under the Open Software License version 2.0
* http://www.opensource.org/licenses/osl-2.0.php
*/

import java.io.*;

/**
* Utility class for generating sequential file extensions.
*
*
* Assume a directory with:

*
* |- file.name.001
* |- file.name.002
* |- file.name.005
*
* What is the next file name in the sequential set?

* file.name.006 or maybe file.name.003

* Depends on what you want to do.
*
* The method nextSequentialFile will generate a
* File object to meet either need.
*
* @author David A. Koontz
*/

public class SequentialExtension {

/**
* Finds the next file extension of a sequential extension.
*
* Given file.001, file.002, file.005 in a directory this
* method will return file.003 when infix == true
* or file.006 when infix == false.
*
* If baseName is null or empty string then every file within the
* directory is considered within the sequential set.
*
* @param directory the directory in which to search
* @param baseName the filename's base part
* @param infix when true gaps in sequence will be infiled
* @return the File with the next sequential number
*/
public File nextSequentialFile(File directory, String baseName, boolean infix) {
File seqFile = null;

if( (directory==null) || (!directory.isDirectory()) )
throw new IllegalArgumentException("Invalid directory");

if ( infix ) {
// start with *.000 or *.001
// int next = 1; // if you want to start with *.001
// just for sanity we limit the sequence loop to *.999

for ( int next = 0; next < 1000; next++ ) {
// generate the next extension in sequential set
String numStr = makeNumericExtension(next);

seqFile = new File(directory, baseName + '.' + numStr);

if ( ! seqFile.exists() ) {
break; // found a non-existant file name - break out of loop & return it
}
}

if ( seqFile == null ) {
throw new UnsupportedOperationException("All sequential files 000 - 999 exist for "+baseName+"!");
}
} else {
// not inclusive - meaning generate extension at end of current set
// so file.001, file.002, file.005 results in file.006
int max = findMaxSequentialExtension(directory, baseName);
int next = max + 1;

// generate the next extension in sequential set
String numStr = makeNumericExtension(next);

seqFile = new File( directory, baseName + '.' + numStr );

}

return seqFile;

}

/**
* Generate a three digit extension (zero padded).
*
* Like: "003" or "023" (also "4321").
*/
private static String makeNumericExtension(int number) {
String numStr = "" + number;
if ( numStr.length() == 1 )
numStr = "00" + number;
else if ( numStr.length() == 2 )
numStr = "0" + number;

return numStr;

}

/**
* Finds the next file extension of a sequential extension.
*
* Given file.001, file.002, file.005 in a directory this
* method will return file.003.
*
* If baseName is null or empty string then every file within the
* directory is considered within the sequential set.
*
* @param directory the directory in which to search
* @param baseName the filename's base part
* @return the File with the next sequential number
*/
public File nextSequentialFile(File directory, String baseName) {
if( (directory==null) || (!directory.isDirectory()) )
throw new IllegalArgumentException("Invalid directory");
// start with *.000 or *.001
// int next = 1; // if you want to start with *.001
// just for sanity we limit the sequence loop to *.999
File seqFile = null;

for ( int next = 0; next < 1000; next++ ) {
// generate the next extension in sequential set
String numStr = "" + next;
if ( numStr.length() == 1 )
numStr = "00"+next;
else if ( numStr.length() == 2 )
numStr = "0"+next;

seqFile = new File(directory, baseName + '.' + numStr);

if ( ! seqFile.exists() ) {
break; // found a non-existant file name - break out of loop & return it
}
}

if ( seqFile == null ) {
throw new UnsupportedOperationException("All sequential files 000 - 999 exist for "+baseName+"!");
}

return seqFile;

}

/**
* Finds the max file extension of a sequential file.
*
* Given file.001, file.002, file.005 in a directory this
* method will return 5.
*
* Uses a FileFilter to search the directory if baseName is
* provided. If baseName is null or empty string then every
* file within the directory is considered within the sequential set.
*
* @param directory the directory in which to search
* @param baseName the filename's base part
* @return the max sequential number
*/
private int findMaxSequentialExtension(File directory, String baseName) {
if( (directory==null) || (!directory.isDirectory()) )
throw new IllegalArgumentException("Invalid directory");
// start with *.000
// int maxValue = 0; // if you want to start with *.001
int maxValue = -1;
File[] files;
if ( baseName!=null && baseName.length()>0 ) {
files = directory.listFiles(new BaseNameFilter(baseName));
} else {
files = directory.listFiles();
}
for(int i=0; i < files.length; i++) {
// ignore directories & do not recurse into sub-dir
if(files[i].isFile()) {
String name = files[i].getName();
int dotIndex = name.lastIndexOf('.');
// if no dot lastIndexOf returns -1
// what about unix hidden (dot) files
if (dotIndex > 0) {
// only if there is a basename
String ext = name.substring(dotIndex+1);

System.out.println( "found ext = " + ext );
try {
int num = Integer.parseInt(ext);
if ( num > maxValue ) maxValue=num;
}catch(NumberFormatException nfe) {
; // ignore
}
}
}
}

return maxValue;
}

/**
* Strips path and extension from a filename.
*
*/
public static String getBaseName( String name )
{
// strip path.
String base = new File( name ).getName();
// strip possible extension.
int index = base.lastIndexOf( '.' );
if( index != -1 )
base = base.substring( 0, index );

return base;
}

/**
* Strips path and extension from a filename.
*
* example: path/file.name.txt -> file.name
*
* Note: define extension as the substring after the last dot.
*
*/
public static String getBaseName( File name )
{
// strip path.
String base = name.getName();
// strip possible extension.
int index = base.lastIndexOf( '.' );
if( index != -1 )
base = base.substring( 0, index );

return base;
}

/**
* Strips path and base name from a filename.
*
* example: path/file.txt -> txt
*
* Note: define extension as the substring after the last dot.
*
* example: path/long.file.name.ext -> ext
*/
public static String getFileExtension( File file, boolean keepDot )
{
// strip path
String base = file.getName();
// strip possible extension
String extension = "";
int index = base.lastIndexOf( '.' );
if( index != -1 )
{
if( keepDot )
extension = base.substring( index );
else
extension = base.substring( index + 1 );
}
return extension;
}

/**
* A Filter for filenames of a given base name.
*
* For use in File.listFiles

*
* File[] files = directory.listFiles(BaseNameFilter("MyFile"));
*

* Would return MyFile.001, MyFile.002, MyFile.txt, etc.
*/
class BaseNameFilter implements FileFilter {
// inner class
private String name;
BaseNameFilter(String baseName) {
name = baseName;
}
public boolean accept(File f) {
//
String bn = getBaseName(f.getName());
// is file system case sensitive? how would I know?
// shouldn't Java System know?
// if ( name.equalsIgnoreCase(bn) ) {
if ( name.equals(bn) ) {
return true;
}
return false;
}
}

/**
* A Filter for filenames of a given extension.
*
* For use in File.listFiles

*
* File[] files = directory.listFiles(ExtensionFilter("txt"));
*

* Would return junk.txt, apple.txt, MyFile.txt, etc.
*/
class ExtensionFilter implements FileFilter {
// inner class
private String name;
ExtensionFilter(String extension) {
name = extension;
}
public boolean accept(File f) {
//
String ext = getFileExtension(f, false);
// is file system case sensitive? how would I know?
// shouldn't Java System know?
// if ( name.equalsIgnoreCase(ext) ) {
if ( name.equals(ext) ) {
return true;
}
return false;
}
}

/**
* Unit testing the Filters & findMaxSequentialExtension()
*/
public static void main( String[] args ) {

File nextFile = null;
String baseName = "file.name";

SequentialExtension se = new SequentialExtension(".");

// generate the next extension (not infix) in sequential set

nextFile = se.nextSequentialFile(se.cwd, baseName, false);

try {
if ( nextFile.createNewFile() ) {
System.out.println("Created " + nextFile.getName() );
} else {
System.out.println("Failed to create " + nextFile.getName() );
}
} catch (IOException ex) {
System.out.println("Failed" + ex);
}

// generate the infixed extension within a sequential set

nextFile = se.nextSequentialFile(se.cwd, baseName, true);
try {
if ( nextFile.createNewFile() ) {
System.out.println("Created " + nextFile.getName() );
} else {
System.out.println("Failed to create " + nextFile.getName() );
}
} catch (IOException ex) {
System.out.println("Failed" + ex);
}

se.list(baseName);

/* This is program output after a few runs & deleting a few files
Note the missing files (003 & 004).

found ext = 000
found ext = 001
found ext = 002
found ext = 005
found ext = 006
Created file.name.007
Created file.name.003
List of 'file.name' files:
file.name.000
file.name.001
file.name.002
file.name.005
file.name.006
file.name.007
file.name.003

*/

se.list();
}

File cwd;

public SequentialExtension(String dir) {
cwd = new File(dir);
}

public void list(String basename) {
File[] files = cwd.listFiles(new BaseNameFilter(basename) );
System.out.println("List of '" + basename + "' files:");
for (int i = 0; i < files.length; i++) {
System.out.println(" "+ files[i].getName() );
}
}
public void list() {
File[] files = cwd.listFiles( );
System.out.println("List of files:");
for (int i = 0; i < files.length; i++) {
System.out.println(" "+ files[i].getName() );
}
}

}

/*
* Copyright (c) 2003 David A. Koontz
* Licensed under the Open Software License version 2.0
* http://www.opensource.org/licenses/osl-2.0.php
*/

TelephoneNumber - Java class

Mon, 14 Apr 2008 07:13:35 +0200

The TelephoneNumber class was designed to use the java.text.MessageFormat class to format a US phone number with the proper characters and spacing. The class excepts numbers any many different ways and parses them into it's internal data so that it can display the phone number in the standard way, i.e. (800) 555-1212. It can even accept an alpha number like "877 HOLY-COW" and with the right options format it as alpha or numbers.

The TelephoneNumber class represents a US telephone number.

This class contains many constructors for various uses. It then stores the telephone number internally in seperate codes (area code, exchange, etc.). This encourages use of the format method to output the telephone number in any style the programmer wishes.

[needs i18n work]

Example usage:

long number = 8005551212L;
TelephoneNumber phone = new TelephoneNumber(number);
StringBuffer msg = new StringBuffer("Call me at ");
msg.append(phone.format());
// msg is now "Call me at (800) 555-1212"

US Format:
The general US format is a 3 digit area code, a 3 digit exchange, a 4 digit station. Typically written (800) 555-1212. Area codes are concidered optional unless you live in a '10 digit' calling area as many people now do. In which case you may want to set the isTenDigitArea flag which removes the parenthesis from the String output ie Denver area code requires 10 digit dailing 303 555-1212.

International Format:
International phone numbers are often written in this format:
+CC-(N)AAA-EEE-SSSS.
This expresses the numbers used for both international and national long-distance calls. In the example, +CC indicates the country code, while (N) indicates the NDD. When dialing from outside the country, the NDD would not be used after dialing the country code; when dialing from within that country, the NDD would be used, but the country code would not. Where AAA indicates the area code, EEE indicates the exchange, and SSSS indicates the station.

Country Code:
The country code is the national prefix to be used when dialing TO that particular country FROM another country.

NDD Prefix: (National Direct Dialing)
The NDD prefix is the access code used to make a call WITHIN that country from one city to another (when calling another city in the same vicinity, this may not be necessary). The NDD is followed by the city/area code for the place you are calling.

IDD Prefix: (International Direct Dialing)
The IDD prefix is the international prefix needed to dial a call FROM a country TO another country. This is followed by the country code for the country you are calling. The IDD is not part of the telephone number - but is a property of the locale, or the 'dailing device'.

Outside Line Prefix:
The Outside line prefix is use inside some private branch exchange (PBX) to connect with the outer exchange/trunk. It is typically 9 in the average US company. This is not part of the telephone number - but once again the property of the locale, or the 'dailing device'.

/*
* Copyright (c) 2003 David A. Koontz
* Licensed under the Open Software License version 2.0
*
* See: http://www.opensource.org/licenses/osl-2.0.php
* Grant of Copyright License. Licensor hereby grants You a world-wide,
* royalty-free, non-exclusive, perpetual, sublicenseable license to
* do the following:

* a) to reproduce the Original Work in copies;
* b) to prepare derivative works ("Derivative Works") based upon
* the Original Work;
* c) to distribute copies of the Original Work and Derivative Works
* to the public, with the proviso that copies of Original Work or
* Derivative Works that You distribute shall be licensed under the
* Open Software License;
* d) to perform the Original Work publicly; and
* e) to display the Original Work publicly.
*/

//package com.<somewhere>.util;

import java.text.MessageFormat;

/**
* The <code>TelephoneNumber</code> class represents a US telephone number.
* 
* This class contains many constructors for various uses. It then stores the
* telephone number internally in seperate codes (area code, exchange, etc.).
* This encourages use of the <code>format</code> method to output the
* telephone number in any style the programmer wishes.
* 
* [needs i18n work]
* 
* Example usage: 
* <Blockquote><code><pre>
* long number = 8005551212L;
* TelephoneNumber phone = new TelephoneNumber(number);
* StringBuffer msg = new StringBuffer("Call me at ");
* msg.append(phone.format());
* // msg is now "Call me at (800) 555-1212"
* </pre></code></Blockquote>
* 
* US Format: 
* The general US format is a 3 digit area code, a 3 digit exchange, a 4 digit
* station. Typically written (800) 555-1212. Area codes are concidered
* optional unless you live in a '10 digit' calling area as many people now do.
* In which case you may want to set the <code>isTenDigitArea</code> flag which
* removes the parenthesis from the String output ie Denver area code
* requires 10 digit dailing 303 555-1212.
* 
* International Format: 
* International phone numbers are often written in this format: 
* +CC-(N)AAA-EEE-SSSS. 
* This expresses the numbers used for both international and
* national long-distance calls. In the example, +CC indicates
* the country code, while (N) indicates the NDD. When dialing
* from outside the country, the NDD would not be used after dialing
* the country code; when dialing from within that country, the NDD
* would be used, but the country code would not. Where AAA indicates
* the area code, EEE indicates the exchange, and SSSS indicates the
* station.
* 
* 
*
* Country Code: 
* The country code is the national prefix to be used when dialing TO
* that particular country FROM another country.
* 
*
* NDD Prefix: (National Direct Dialing) 
* The NDD prefix is the access code used to make a call WITHIN
* that country from one city to another (when calling another city in
* the same vicinity, this may not be necessary).
* The NDD is followed by the city/area code for the place you are
* calling.
* 
*
* IDD Prefix: (International Direct Dialing) 
* The IDD prefix is the international prefix needed to dial a call
* FROM a country TO another country. This is
* followed by the country code for the country you are calling.
* The IDD is not part of the telephone number - but is a property of
* the locale, or the 'dailing device'.
* 
* Outside Line Prefix: 
* The Outside line prefix is use inside some private branch exchange (PBX)
* to connect with the outer exchange/trunk. It is typically 9 in the
* average US company. This is not part of the telephone number - but
* once again the property of the locale, or the 'dailing device'.
*
*
*
* @author David A. Koontz <a href="mailto:dakoontz@yahoo.com">[dakoontz@yahoo.com]</a>
* @version 1.0, 7/20/2003
* @see MessageFormat
* @see <a href="http://www.opensource.org/licenses/osl-2.0.php">Open Software License</a> version 2.0
*
*/
public class TelephoneNumber {

// International direct dial code is not part of a telephone
// number - it would be info in the locale that the dialer is in.
/** National direct dial code */
protected String ndd; // NDD of US is 1; UK is 0
/** Country code */
protected String countryCode; // Country code of US is 1; UK is 44
/** Area code */
protected String areaCode;
/** Exchange */
protected String exchange;
/** Station */
protected String station;
/** Extension */
protected String extension;
/** Is phone number part of a ten digit dialing area. */
protected boolean isTenDigitArea = false;
/** Alphanumeric phone number */
protected String alphaNumber; // used when we store "(800) GOT MILK"
/** Is phone number an alphanumberic */
protected boolean isAlphaNumber = false;

/** The default format pattern - US centric */
protected String defaultPatternUS = "({2}) {3}-{4}";
/** The default format pattern */
protected String defaultPattern = defaultPatternUS;

/**
* Basic constructor.
*/
public TelephoneNumber() {
this(null, null, null, "555", "1212", null);
}

/**
* General constructor.
* Create +1-(1)(800) 555-1212 ext: 34
*
* @param countryCode the country code (US is 1; UK is 44)
* @param ndd the national direct dial code (US is 1; UK is 0)
* @param areaCode the area code (or city code)
* @param exchange the exchange
* @param station the station
* @param extension the extension (inside the PBX)
*/
public TelephoneNumber(String countryCode, String ndd, String areaCode, String exchange, String station, String extension) {
if ( exchange == null )
throw new IllegalArgumentException("null arg forms not allowed for 'exchange'");
if ( station == null )
throw new IllegalArgumentException("null arg forms not allowed for 'station'");
this.countryCode = countryCode;
this.ndd = ndd;
this.areaCode = areaCode;
this.exchange = exchange;
this.station = station;
this.extension = extension;
}

/**
* Create (800) 555-1212 ext: 34
*/
public TelephoneNumber(String areaCode, String exchange, String station, String extension) {
this(null, null, areaCode, exchange, station, extension);

}

/**
* Create 555-1212 ext: 34
*/
public TelephoneNumber( String exchange, String station, String extension) {
this(null, null, null, exchange, station, extension);

}

/**
* Create 555-1212
*/
public TelephoneNumber( String exchange, String station) {
this(null, null, null, exchange, station, null);

}

/**
* Create 888 HOLY COW by using alphanumeric digits
*/
public TelephoneNumber( boolean isAlphaNumeric, String alphaNumber) {
this();
this.isAlphaNumber = isAlphaNumeric;
if ( isAlphaNumber == true ) {
this.alphaNumber = alphaNumber;
// parse it
String[] nums = parse(convertFromAlpha(alphaNumber));
// ignore country code & NDD
this.areaCode = nums[1];
this.exchange = nums[2];
this.station = nums[3];
this.extension= nums[4];

} else {
// parse this also - assuming no alpha char.
String[] nums = parse(alphaNumber);
// ignore country code & NDD
this.areaCode = nums[1];
this.exchange = nums[2];
this.station = nums[3];
this.extension= nums[4];
}
}

/**
* Create (888) 555-1212 by parsing string
*/
public TelephoneNumber( String str) {
this();
// parse the string into numbers array
String[] nums = parse(str);
// ignore country code & NDD
this.areaCode = nums[1];
this.exchange = nums[2];
this.station = nums[3];
this.extension= nums[4];
}

/**
* Create (479) 555-1212 by parsing a long integer
*/
public TelephoneNumber(long number) {
this();
String[] nums = parse(number);

// convert from longs to strings
this.areaCode = nums[1];
this.exchange = nums[2];
this.station = nums[3];

}

/** Create 555-1212 via long integers
*/
public TelephoneNumber( long exchange, long station) {
this();
// convert from longs to strings
if (exchange > 0) {
this.exchange = String.valueOf(exchange);
}
if (station > 0) {
this.station = String.valueOf(station);
}
}

/**
* Create (479) 555-1212 via long integers
*/
public TelephoneNumber(long areaCode, long exchange, long station) {
this();
// convert from longs to strings
if (areaCode > 0) {
this.areaCode = String.valueOf(areaCode);
}
if (exchange > 0) {
this.exchange = String.valueOf(exchange);
}
if (station > 0) {
this.station = String.valueOf(station);
}
}

/**
* Parse a string like "(888) 555-1212 x 68" into a phone number.
* Requires area code.
* Does not allow country codes etc.
* US centric.
*/
protected String[] parse( String str) {
String[] numbers = new String[5];
StringBuffer ndd = new StringBuffer();
StringBuffer area = new StringBuffer();
StringBuffer exch = new StringBuffer();
StringBuffer stat = new StringBuffer();
StringBuffer ext = new StringBuffer();
char ch = ' ';
int areaCount = 0;
int exchCount = 0;
int statCount = 0;

if ( str != null && str.length()>0 ) {
// for each char in string
for (int i = 0; i < str.length(); i++) {
ch = str.charAt(i);
// only look at digits
if ( Character.isDigit(ch) ) {
// this is only finding this pattern 123 123 1234 99...
if ( areaCount < 3 ) {
area.append(ch);
areaCount++;
} else if ( exchCount < 3 ) {
exch.append(ch);
exchCount++;
} else if ( statCount < 4 ) {
stat.append(ch);
statCount++;
} else {
ext.append(ch);
}
// doesnot work for "571 3345 ext 897"
//@todo - get better parser
}

}
}
numbers[0] = ndd.toString();
numbers[1] = area.toString();
numbers[2] = exch.toString();
numbers[3] = stat.toString();
numbers[4] = ext.toString();

return numbers;
}

/**
* Parse a long integer like 4795718080 into phone number.
* Does not allow country codes or extensions.
* US centric.
*/
protected String[] parse(long number) {
String[] nums = new String[5];
long area = 0;
long exch = 0;
long stat = 0;
// parse the long from right to left
// assume US style phone number without extension
// example: 8005551212 or 2368000
if (number > 0) {
if (number > 9999) {
exch = number / 10000;
stat = number - (exch * 10000);
if ( exch > 999 ) {
area = exch / 1000;
exch = exch - (area * 1000);
}
}
}
// convert from longs to strings
if (area > 0) {
nums[1] = String.valueOf(area);
}
if (exch > 0) {
nums[2] = String.valueOf(exch);
}
if (stat > 0) {
nums[3] = String.valueOf(stat);
}

return nums;
}

/** Convert alphanumeric phone number to numeric. */
protected static String convertFromAlpha(String alpha) {
// If you don't want US style key pad - change it.
return convertFromAlphaUS(alpha);
}

/** Convert alphanumeric phone number to numeric - US centric */
protected static String convertFromAlphaUS(String alpha) {
// convert a US alphanumeric number into numberic
// example: 800 GOT MILK -> 800 468-6455
// where the Alpha to Numberic Key Pad
//
// 1 2 3
// ABC DEF
//
// 4 5 6
// GHI JKL MNO
//
// 7 8 9
// PQRS TUV WXYZ
//
// * 0 #
//

// prep the alpha string
StringBuffer sb = new StringBuffer(alpha.toUpperCase().trim());

// for each char in the string
for (int i = 0; i < sb.length(); i++) {
char ch = sb.charAt(i);
if ( Character.isDigit(ch) ) {
; // ignore it
} else if ( ch == '(' || ch == ')' ) {
; // ignore them
} else if ( ch == 'A' || ch == 'B' || ch == 'C' ) {
sb.deleteCharAt(i);
sb.insert(i, '2');
} else if ( ch == 'D' || ch == 'E' || ch == 'F' ) {
sb.deleteCharAt(i);
sb.insert(i, '3');
} else if ( ch == 'G' || ch == 'H' || ch == 'I' ) {
sb.deleteCharAt(i);
sb.insert(i, '4');
} else if ( ch == 'J' || ch == 'K' || ch == 'L' ) {
sb.deleteCharAt(i);
sb.insert(i, '5');
} else if ( ch == 'M' || ch == 'N' || ch == 'O' ) {
sb.deleteCharAt(i);
sb.insert(i, '6');
} else if ( ch == 'P' || ch == 'Q' || ch == 'R' || ch == 'S') {
sb.deleteCharAt(i);
sb.insert(i, '7');
} else if ( ch == 'T' || ch == 'U' || ch == 'V' ) {
sb.deleteCharAt(i);
sb.insert(i, '8');
} else if ( ch == 'W' || ch == 'X' || ch == 'Y' || ch == 'Z' ) {
sb.deleteCharAt(i);
sb.insert(i, '9');
} else {
; // ignore
}

}

return sb.toString();
}

/**
* Format the telephone number with the supplied <code>MessageFormat</code> pattern.
* The pattern has 7 <code>messageFormatElement</code> arguments (0 - 6).
* 
* argument 0 - ndd 
* argument 1 - countryCode 
* argument 2 - areaCode 
* argument 3 - exchange 
* argument 4 - station 
* argument 5 - extension 
* argument 6 - alphanumeric 
* 
* Examples: 
* "({2}) {3}-{4} ext {5}" gives "(800) 555-1212 ext 99" 
* "{2}.{3}.{4}" gives "800.555.1212" 
* "{6} [{2} {3}-{4}]" gives "888 HOLY COW [888 465-9269]" 
*
* @param pattern the format pattern to be used
* @see MessageFormat
*
*/
public String format(String pattern) {
// create objects array from telephone codes
Object[] objects = {ndd, countryCode, areaCode, exchange, station, extension, alphaNumber};

// create a MessageFormat with pattern
MessageFormat mf = new MessageFormat(pattern);
return mf.format(objects);
}

/**
* Format the telephone number with the <code>defaultPattern</code> <code>MessageFormat</code>.
* US centric.
*/
public String format() {
// create objects array from telephone codes
Object[] objects = {ndd, countryCode, areaCode, exchange, station, extension, alphaNumber};

// create a MessageFormat with default pattern
MessageFormat mf = new MessageFormat(defaultPattern);
return mf.format(objects);
}

/** Human readable output
*/
public String toString() {
return toStringUS();
}

/** US centric human readable output
*/
public String toStringUS() {
// use US convention: "(800) 555-1212 ext: 20"
StringBuffer sb = new StringBuffer(20);
if ( this.isAlphaNumber ) {
// just spit back the string
sb.append(this.alphaNumber);
sb.append(" [").append(areaCode).append(" ").append(exchange).append(" ").append(station).append("]");
} else {

if (countryCode != null && countryCode.length() > 0) {
// format country code as '+CC-'
sb.append("+").append(countryCode).append("-");
}
if (ndd != null && ndd.length() > 0) {
if (countryCode != null && countryCode.equals("1") ) {
// in the US we don't write both the country code & the NDD
; // igonre the NDD
} else {
// format NDD as '(N) '
sb.append("(").append(ndd).append(") ");
}
}

if (areaCode != null && areaCode.length() > 0) {
// we could use a java.text.Format - but noooooo
// assume US style (000)
if ( areaCode.length() == 1 ) {
if (isTenDigitArea == true) {
sb.append("00").append(areaCode).append(" ");
} else {
sb.append("(").append("00").append(areaCode).append(") ");
}
} else if (areaCode.length() == 2 ) {
if (isTenDigitArea == true) {
sb.append("0").append(areaCode).append(" ");
} else {
sb.append("(").append("0").append(areaCode).append(") ");
}
} else if (areaCode.length() == 3 ) {
if (isTenDigitArea == true) {
sb.append(areaCode).append(" ");
} else {
sb.append("(").append(areaCode).append(") ");
}
} else {
// more than 3 digits? - OK whatever
if (isTenDigitArea == true) {
sb.append(areaCode).append(" ");
} else {
sb.append("(").append(areaCode).append(") ");
}
}
}

// exchange - assume US style 000
if ( exchange.length() == 1 ) {
sb.append("00").append(exchange).append("-");
} else if (exchange.length() == 2 ) {
sb.append("0").append(exchange).append("-");
} else if (exchange.length() == 3 ) {
sb.append(exchange).append("-");
} else {
// more than 3 digits? - OK whatever
sb.append(exchange).append("-");
}

// station - assume US style 0000
if ( station.length() == 1 ) {
sb.append("000").append(station);
} else if (station.length() == 2 ) {
sb.append("00").append(station);
} else if (station.length() == 3 ) {
sb.append("0").append(station);
} else {
sb.append(station);
}

if (extension != null && extension.length() > 0) {
sb.append(" ext: ").append(extension);
}
}

return sb.toString();
}

/** MAIN - a test stub */
public static void main(String[] args) {
// test it out
TelephoneNumber n1 = new TelephoneNumber(); // test null params
TelephoneNumber n2 = new TelephoneNumber(571L, 9999L); // test 2 longs
TelephoneNumber n3 = new TelephoneNumber(479L, 571L, 1003L); // test 3 longs
TelephoneNumber n4 = new TelephoneNumber(303L, 222L, 7800L); // test ten digit dialing
n4.isTenDigitArea = true;

TelephoneNumber n5 = new TelephoneNumber("(888) 341-8876"); // test formated string
TelephoneNumber n6 = new TelephoneNumber(127, 345, 8765); // test 3 integers
TelephoneNumber n7 = new TelephoneNumber(true, "800 GOT MILK"); // test parsing Alpha
TelephoneNumber n8 = new TelephoneNumber(3L, 4L, 5L); // test zero padding
TelephoneNumber n9 = new TelephoneNumber("1", "1", "479", "571", "8509", "40"); // test 6 strings
TelephoneNumber n10 = new TelephoneNumber(9876543210L); // test 1 long
TelephoneNumber n11 = new TelephoneNumber(false, "/800/ 555-1212 x 0"); // test parsing Non-Alpha

System.out.println("TelephoneNumber(): " + n1);
System.out.println("TelephoneNumber(571L, 9999L): " + n2);
System.out.println("TelephoneNumber(479L, 571L, 1003L): " + n3);
System.out.println("TelephoneNumber(303L, 222L, 7800L): " + n4);
System.out.println("TelephoneNumber(\"(888) 341-8876\"): " + n5);
System.out.println("TelephoneNumber(127, 345, 8765): " + n6);
System.out.println("TelephoneNumber(true, \"800 GOT MILK\"): " + n7);
System.out.println("TelephoneNumber(3L, 4L, 5L): " + n8);
System.out.println("TelephoneNumber(\"1\", \"1\", \"479\", \"571\", \"8509\", \"40\"): " + n9);
System.out.println("TelephoneNumber(9876543210L): " + n10);
System.out.println("TelephoneNumber(false, \"/800/ 555-1212 x 0\"): " + n11);
System.out.println("TelephoneNumber.format(\"{6} [{2} {3}-{4}]\"): " + n7.format("{6} [{2} {3}-{4}]"));
System.out.println("TelephoneNumber.format(): " + n9.format());
}

/******************************************************************/
/*** Getter/Setter ***/
/******************************************************************/

public String getNdd() {
return ndd;
}

public void setNdd(String value) {
ndd = value;
}

public String getCountryCode() {
return countryCode;
}

public void setCountryCode(String value) {
countryCode = value;
}

public String getAreaCode() {
return areaCode;
}

public void setAreaCode(String value) {
areaCode = value;
}

public String getExchange() {
return exchange;
}

public void setExchange(String value) {
exchange = value;
}

public String getStation() {
return station;
}

public void setStation(String value) {
station = value;
}

public String getExtension() {
return extension;
}

public void setExtension(String value) {
extension = value;
}

public boolean isTenDigitArea() {
return isTenDigitArea;
}

public void setTenDigitArea(boolean value) {
isTenDigitArea = value;
}

public String getAlphaNumber() {
return alphaNumber;
}

public void setAlphaNumber(String value) {
alphaNumber = value;
}

public boolean isAlphaNumber() {
return isAlphaNumber;
}

public void setAlphaNumber(boolean value) {
isAlphaNumber = value;
}
}

Refactoring - examples from the book

Mon, 14 Apr 2008 06:56:04 +0200

Martin Fowler's book Refactoring: Improving the Design of Existing Code has a simple example of a movie rental domain model, which he refactors from a less than ideal object-oriented design to a more robust OO design. Included in this Refactoring_FirstExample.zip Zip file are the Java source code files of the Movie, Rental, and Customer classes. Along with a JUnit CustomerTest class. Using these example source files you too can follow along with the refactoring that Fowler presents in the first few chapters of his book.