Who’s On Phirst

Book review: Testing Extreme Programming by Lisa Crispin and Tip House

Testing Extreme Programming is part of the Addison-Wesley XP series of books. The most well known book in this series is probably Extreme Programming Explained: Embrace Change, by Kent Beck. Since one of the frustrating things about being a QA engineer or software tester on an agile or XP project is that there is hardly mention of the role of QA or the place of the tester in most XP literature, I decided to read this book.

If you do not know much about the tenets of XP, this is briefly explained in the beginning of the book, from a tester's point of view. There is no prerequisite to read Extreme Programming Explained. The first part of the book gives an overview of XP: communication, simplicity, feedback, and courage. Then it goes more in depth about the role of the tester in an XP project and why XP projects need testers. In examining unit testing versus acceptance testing, the authors propose that acceptance tests are not as easy for developers to write as it breaks from their natural workflow. Since this book was written in 2002, this obviously predates Fit for Developing Software: Framework for Integrated Tests by Rick Mugridge and Ward Cunningham. But I do think that, in my experience, developers do not have the same testing focus as a dedicated tester, so, in general, I agree with the authors.

The second part of the book takes the reader on a test drive of an XP project. The authors start the road trip with the release planning and iteration planning phases and explain how the tester can facilitate. Giving real-world examples, I believe their ideas and suggestions can be very helpful, especially to the tester who has never worked with XP. The authors then go into great detail describing how acceptance tests should be developed and automated. Using JUnit as an example, the authors show how to quickly automate acceptance tests. Here the authors make the assertion that Java is easy to write. I'm sure this is just to encourage the tester to dive in, but if the tester is technically weak, I'm not sure that the examples would be easily digested. A technically weak tester would need to pair with a developer to overcome this. But overall, the presentation is good.

The last section of the book explains how to use these ideas in less than ideal XP situations. Ideas are given for collaborating and communicating in large or distributed environments that are very helpful. Also, the authors conclude that you can use these ideas to gradually ease a project into XP, or even just for the test organization on a waterfall project.

One slight nag I have about this book is that the example project that is given in the book is a web application called XTrack (similar to XPlanner) at xptester.org. The xptester.org website is now defunct, but it would have been neat to actually view the website while reading the book. Also Brian Marick's old testing.com website is referenced (this is now exampler.com). But such is the danger of print. It would be great if there was a second edition, but it looks like Lisa Crispin has moved on to co-authoring another book.

In reading this book, I have made notes of concepts that I would like to explore in the future and hopefully apply to my day-to-day work. Overall, I'd recommend this book to both new and experienced testers. I rate this book 9 out of 10.

In Untagged 
Comment (0) Read More...

On September 26th, IBM will stop supporting WebSphere 5.1 and its various flavors. Nothing is particularly unusual about software companies ending support for aging products. But, the timing is terrible for customers who wish to upgrade to WebSphere 7.0.

IBM does provide an option for extending your support in a new “5 + 3” support policy. The policy has expanded the standard length of support to five years from three and the length of available extended support to three years from two.

Applying this new policy to WebSphere 6.1, we can expect IBM to reach end standard support on June 30, 2011. If one was to upgrade immediately to 6.1, you would have to migrate again in less than three years. Considering that most upgrades are measured in months, if not years, one could argue that three years is simply not enough time to amortize the upgrade costs. The end result: with the end of life of 5.1 happening before the general availability of 7.0, customers are feeling pressure to purchase the extended support to help them bridge to 7.0.

Moreover, the uncertainty of how long that migration will take is unnerving. Without a large investment of time and energy, one is unable to effectively estimate the migration effort. Simply put, most companies will have to leap before they look. Scary.

There is another option. Phurnace Deliver provides customers the ability to Snapshot a 5.1 instance and Deploy to a 6.1 instance. We will take your System Resources, Servers and other usual suspects, and migrate them to a 6.1 instance. Phurnace Deliver will even redeploy the Applications for you. You might find that you don’t need to rewrite any code and simply needed to move the EAR and System Resources to the new 6.1 instance. Or, you may be able to quickly identify problem areas to resolve before migration.

Either way, it’s a simple, cost effective way to have a look before you leap into an upgrade.

In WebSphere
Comment (0) Read More...

Anyone who’s worked with J2EE application servers has more than a passing familiarity with XML. It’s the weapon of choice for configuration in the 3 platforms I’ve spent most of my time working with; JBoss, WebLogic, and WebSphere. When I first started working at Phurnace, I would verify these files by hand using a diff tool that could handle single documents or a directory tree. I would compare a ‘known good’ configuration to the configuration produced by Phurnace Deliver. This worked great while I was getting my feet wet and finding my way around each platform’s configuration peculiarities.

For obvious reasons, this method sucked a lot after I got a handle on the different configuration conventions used by each platform. The process was incredibly monotonous and error prone. My mind would start to wander as I robotically clicked through the differences in dozens of XML files. Most of the time the differences were expected due to system generated unique IDs or environmental differences. I decided I needed to automate this process simply because I dreaded doing it manually. Because we were dealing with XML, XPath seemed to be the obvious choice for programmatic validation. So I just needed to whip up some XPath expressions and a simple Java class to resolve them and I was done. No bubbles, no troubles. Right?

Well I was forgetting that a WebSphere profile with one node and one server contains more than 100 individual XML files ranging in size from <1K to 600K+. If I thought using the diff tools was tedious, it was nothing compared to generating thousands of XPath expressions by hand. Plus, every time the product expanded into new areas of configuration, I was looking at hours of updating the automation data to keep it current. I needed a tool that would generate these XPath expressions for me. I had some specific needs that weren’t addressed by the sample classes and open source solutions I was finding on the web so I decided to write my own. Keep in mind:

 

• Coding isn’t my forte. You may find bone-headed logic or hacky work-arounds. But for my purposes it works and it’s quick. Consider it your chance to test the tester and file a bug by leaving a comment. I’d love to get feedback and improve it!
• This is a simplified version of the class I use and it works fine on simple XML. This sample class has some limitations. It doesn’t handle namespace designations and I haven’t added handling for special characters. I encourage you to play around with it and add methods that suit your purposes.

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

import org.apache.commons.lang.StringUtils;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class XPathGenerator {

	/*
	 * fileList - a list of files to generate XPath expressions from xpath - an
	 * xpath instance used to verify generated xpaths
	 */
	private static List fileList = new ArrayList();
	private static XPath xpath = XPathFactory.newInstance().newXPath();

	/*
	 * Simple utility method that checks for whitespace at the beginning a text
	 * node
	 */
	private static boolean isWhiteSpace(String nodeText) {
		if (nodeText.startsWith("\r") || nodeText.startsWith("\t")
				|| nodeText.startsWith("\n") || nodeText.startsWith(" "))
			return true;
		else
			return false;
	}

	/*
	 * Simple utility method to verify brutishly assembled xpath expressions
	 */
	private static void checkXPath(String xpathExpression, Node node) {
		Object xpathCheck;
		try {
			xpathCheck = xpath.evaluate(xpathExpression, node
					.getOwnerDocument(), XPathConstants.BOOLEAN);
			if (xpathCheck.toString() == "true") {
				/*
				 * print the file/xpath combo to use for future verification For
				 * Example:
				 * file:/C:/tmp/sample.xml=/rootNode/firstChild/firstGrandChild
				 * [@attrib="value"][text()="some text"]
				 */
				System.out.println(node.getOwnerDocument().getDocumentURI()
						+ "=" + xpathExpression);
			}
		} catch (XPathExpressionException xpe) {
			System.out.println("\n\n" + xpathExpression);
			xpe.printStackTrace();
		}
	}

	/*
	 * Simple utility method to check for a text node on the currenrt XML
	 * element
	 */
	private static boolean hasValidText(Node node) {
		String textValue = node.getTextContent();

		return (textValue != null && textValue != ""
				&& isWhiteSpace(textValue) == false
				&& !StringUtils.isWhitespace(textValue) && node.hasChildNodes());
	}

	/*
	 * Simple utility to check for attributes on the current element
	 */
	private static boolean hasValidAttributes(Node node) {
		return (node.getAttributes().getLength() > 0);

	}

	/*
	 * Build XPath attribute list for individual XML Element Nodes Iterate
	 * through all attribute nodes and build a string that can be included in an
	 * XPath expression to validate an XML document. Resulting string will look
	 * like: [@attrib1="value1" and @attrib2="value2"] Skip this if the
	 * attribute list is empty.
	 */

	private static String buildAttribString(Node node, String pathExpr) {
		NamedNodeMap nnlist = node.getAttributes();
		pathExpr = pathExpr + "[";

		int attribCount = 0;
		// iterate over attributes
		for (int i = 0; i < nnlist.getLength(); i++) {
			// grab attribute name and value
			String attribName = nnlist.item(i).getNodeName();
			String attribValue = nnlist.item(i).getNodeValue();

			// if we've already added attributes to the path expression append
			// the current one
			if (attribCount > 0) {
				pathExpr = pathExpr + " and ";
			}

			pathExpr = pathExpr + "@" + attribName + "=\"" + attribValue + "\"";
			attribCount++;
		}

		pathExpr = pathExpr + "]";

		return pathExpr;
	}

	/*
	 * processNode checks for attributes and text nodes on an xml node and
	 * process them accordingly
	 */
	public static NodeList processNode(Node node) {

		if (hasValidAttributes(node) || hasValidText(node)) {
			String pathExpr = "/" + node.getNodeName();

			// check for attributes
			if (hasValidAttributes(node)) {
				pathExpr = buildAttribString(node, pathExpr);
			}

			// Make a copy of node to preserve it's state
			Node tmpNode = node;

			// Build pathExpr for XPath Expression by working backward through
			// the XML until we hit the document node.
			while (tmpNode.getParentNode() != null
				    && tmpNode.getParentNode().getNodeType() != Node.DOCUMENT_NODE) {

				tmpNode = tmpNode.getParentNode();
				String nodeName = tmpNode.getNodeName();

				if (hasValidAttributes(tmpNode)) {
					String attribString = buildAttribString(tmpNode, nodeName);
					pathExpr = "/" + attribString + pathExpr;
				} else {
					pathExpr = "/" + nodeName + pathExpr;
				}
			}

			if (hasValidText(node)) {

				/*
				 * Build XPath text value expression to verify text values for
				 * node. This is a little tricky because linebreaks, tabs and
				 * spaces included in the XML document are considered text
				 * nodes.
				 */

				// Copy original node to a textNode to preserve state of
				// original node for future operations
				Node textNode = node;

				/*
				 * This check iterates through child nodes of the original node
				 * until it reaches the next element node. As long as the node
				 * is not null, starts with white space and is not an element
				 * node, move on to the next node
				 */
				while (textNode != null
					      && isWhiteSpace(textNode.getTextContent()) == true
					      && StringUtils.isWhitespace(textNode.getTextContent())
					      && textNode.getNodeType() != Node.ELEMENT_NODE) {
					textNode = textNode.getFirstChild();
				}

				/*
				 * If the text content of the current node is not null, doesn't
				 * start with whitespace and has child nodes, we grab the text
				 * and frame it into an XPath text argument. A sample element
				 * and it's resulting text argument:
				 * 
				 * some text here YIELDS
				 * element1[text()="some text here"]
				 * 
				 * NOTE: The check for child nodes prevents us from creating a
				 * blank text argument for self contained elements (example:
				 * )
				 */
				pathExpr = pathExpr + "[text()=\""
			                   + StringUtils.strip(textNode.getTextContent()) + "\"]";

			}

			checkXPath(pathExpr, node);
		}
		// gather children and return
		return node.getChildNodes();
	}

	// This function takes a group of nodes and generates XPath expressions for
	// them until it runs out of nodes
	public static void processNodeList(NodeList nodelist) {
		for (int i = 0; i < nodelist.getLength(); i++) {
			if (nodelist.item(i).getNodeType() == Node.ELEMENT_NODE
			      && (hasValidAttributes(nodelist.item(i)) || hasValidText(nodelist
					   	.item(i)))) {
				processNode(nodelist.item(i));
			}
			processNodeList(nodelist.item(i).getChildNodes());
		}
	}

	// This function takes the cmd line argument and adds to fileList all files
	// in the directory and it's subdirectory
	private static void processDir(File dir) {
		File[] fileArray = dir.listFiles();

		for (int i = 0; i < fileArray.length; i++) {
			if (fileArray[i].isFile()) {
				if (fileArray[i].toString().endsWith(".xml")) {
					fileList.add(fileArray[i]);
				}
			} else if (fileArray[i].isDirectory()) {
				processDir(fileArray[i]);
			}
		}
	}

	// This starts the process of an individual XML file
	private static void processXML(File xmlFile) throws SAXException,
			IOException, ParserConfigurationException, XPathExpressionException {
		try {
			DocumentBuilderFactory factory = DocumentBuilderFactory
					.newInstance();
			factory.setIgnoringComments(true);

			DocumentBuilder parser = factory.newDocumentBuilder();
			Document doc = parser.parse(xmlFile);

			NodeList startlist = doc.getChildNodes();

			processNodeList(startlist);
		} catch (Exception e) {

		}
	}

	/*
	 * Entry point. Pass in the xml file or top level directory of a group of
	 * files to generate XPath expressions for them.
	 */

	public static void main(String[] args) {
		File startDir = new File(args[0]);
		try {
			if (startDir.isFile()) {
				processXML(startDir);
			} else if (startDir.isDirectory()) {
				processDir(startDir);
				for (int i = 0; i < fileList.size(); i++) {
					processXML(fileList.get(i));
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

In Xpath Expressions, XML
Comment (3) Read More...

When I was younger, I considered running to stay in shape to be about as much fun as a root canal. Tennis, basketball, and softball occupied my time, as they provided the diversion of the particular ball that the sport involved. Now a days, however, I find myself enjoying the sheer simplicity of running. The uniform is simple, just shoes, shorts, and an optional shirt, and in Austin, you don't even have to leave your neighborhood to enjoy a great course. I'd like to share a couple of runs that I really enjoy.

Most of my running starts from the legendary "Rock", which is located underneath the Mopac foot bridge near Austin High. From here, one of my favorite runs is to head out Lake Austin Boulevard until it hits Scenic Drive. Scenic provides a very nice view of Lake Austin, and several nice, but very runnable hills. I like to follow Scenic until it hits Pecos Street, and then take a right. Pecos runs right through the heart of Tarrytown, which used to be considered a suburb in Old Austin. Pecos hits Enfield Road, which has a nice hill right before you get to Exposition Boulevard. From the top of this hill, you can see the Texas State Capitol in downtown Austin. Enfield crosses under Mopac again, where you can take a right and run through Clarksville, a neighborhood founded by freed slaves. Clarksville to me is the kind of neighborhood that really represents the funky-cool character of Austin. From the western edge of Clarksville, you are treated to a great view of the Texas Hill Country, right before you descend back to the Rock. This run comes in at just over 8 miles.

One of the newer runs that I just started doing in the last year is one that takes me south of the Colorado River. This is another great neighborhood in Austin, which despite fairly rapid gentrification, has still managed to maintain its look-and-feel. The absolute highlight of this run is a viewing of the Mary Street Goat. I kid you not, this is a live goat, complete with horns and a beard. Most mornings, he's out in the front yard of his owner's house, located near Congress Avenue. You can then take Congress north to the Lady Bird Lake Hike and Bike Trail, while enjoying a great view of the unofficial Main Street of Texas, and another view of the State Capitol. This run covers between 8-9 miles.

My early morning running puts me in the perfect frame of mind to write some kick-butt software here at Phurnace, while trying to avoid the middle-age spread. I've made some great friends, and I'm able to experience an Austin that a lot of people aren't fortunate enough to get to enjoy.

In Untagged 
Comment (0) Read More...

The best part about a vacation get-away is the getting away from it all – away from work, away from household chores and getting out of the rat race. The next best thing is coming back home to familiarity – sleeping in your own bed, eating food you recognize, clean restrooms, etc. The “coming back home” experience can be really special when returning from another country where things like food, customs, and various creature comforts are just not the same as in the good old USA. We don’t often appreciate the little things. I think it is healthy to be reminded of what we do have here, by seeing other places.

I recently returned from a week-long trip to Trinidad and Tobago and boy is it nice to be home! Don’t get me wrong – Trinidad is a great place to visit with wonderful people, beautiful tropical forests, and awesome beaches. My visit to Trinidad was not your typical Caribbean island vacation get-away. But, that was by choice. I spent a week in Trinidad with a team of 18 people from my church conducting a Vacation Bible School for children. Before we left the states I was explaining to my 14 year old son how Trinidad is not a third-world country, yet the day we arrived the electricity went out in the town of Gasparillo where we were staying. Consequently, when the electricity went out the household water pump stopped working leaving us with no running water. My son quickly pointed out to me, “Dad, now we are in a third-world country”. Amazing how we all view the world through our own reference point. I must point out, that the locals didn’t freak out a bit.

The driving in Trinidad is either frightening or exhilarating, depending on your point of view. First off, they drive on the left side, or should I say (as an American driver) the “wrong” side of the road. Rarely do they stop at stop signs and when they come to an intersection they all cram their cars in together and aggressively negotiate who goes next by moving their vehicle within inches of each other. Eventually someone gives in, toots their horn and waves the other car in, or yells something like “go on boy”. It just seems to all work. Not really sure how, but it does.

The most beautiful place we visited in Trinidad was Maracas Bay. Even short-term missionaries deserve their day in the sun. We spent a day eating Bake-N-Shark sandwiches, body surfing, and just limin’ on the beach. The waves at Maracas Bay are very powerful and can hurt you if you’re not careful. A teenage girl in our group was pummeled by a large wave and broke her collar bone. As in all new endeavors or experiences -- “be prepared”.

Some of the experiences from my trip that made me really appreciate the things we too often take for granted were the daily cold showers (or no showers), very hot and humid weather (even though Austin does have its share, Trinidad has it beat in that department), no air conditioning, large downpours of rain every day, and tons of mosquitoes. However, none of that dampened our great experience.

In spite of the temporary discomforts in Trinidad, I’ll definitely be going back again. The people were fantastic and we achieved our objectives. Using vacation time to serve others is rewarding and the kindness and friendship returned was well worth the investment.

In Untagged 
Comment (0) Read More...

Ant, the de-facto standard build tool for Java, could be defined as a platform independent scripting tool similar to Make but with an XML syntax. Ant is mature, extensible, and relatively easy to use. These qualities paved the path for Ant to be applied to other problems besides "building software". For instance, Ant is commonly used as a scripting tool to move files around, and moreover as a test tool to launch tests and generate reports. Most Java developers already know everything I just said.

I would like to share with you another way Ant can add value to your organization, embedded Ant. It is often the case where your software needs to do tasks similar to those available in Ant. For a long while, this was a cool thought, but not a good solution in practice. It required either launching Ant in another process or studying the Ant source code so you can work through some significant issues.

However, improvements in 1.6 and 1.7 now allow Ant to be easily embedded. I first successfully embedded Ant about six months ago with version 1.6. I considered the following points before making the decision to give it a try.

• Ant is very mature.
• The wide usage of Ant implies a well tested infrastructure
• Ant tasks are cross platform
• High probability anyone who inherits this code will know Ant

My product requirements for this feature were that it:

• Must be able to fork a Java JRE on multiple OS's and run a process to completion (Windows, AIX, Linux).
• Must be able to kill or stop the process on-demand.
• Must be able to capture the standard output and standard error in real time.

Sure, I could use the Java IO and Runtime; however, when weighing the cost to write, debug, and test this code versus taking the time to figure out how to embed Ant, the decision was easy.

Here is a quick tutorial that demonstrates the concept. In practice, I use more code to make this easier. However, this shows the concept.

• Create your build.xml and package it in jar.

 

<project name="embedded-ant-example" default="_init">
 
     <target name="sayHello">
 
           <echo>Hello ${to}</echo>
 
     </target>
   </project>
       

 
• Create an Ant Wrapper

Project project = new Project();
 
project.init();
 
project.setBasedir(workingDir);
 
DefaultLogger antLogger = new DefaultLogger();
antLogger.setErrorPrintStream(System.err);
antLogger.setOutputPrintStream(System.out);
antLogger.setMessageOutputLevel(Project.MSG_INFO);
 
project.addBuildListener(antLogger);
 
// Load the build file
InputStream is = MyClass.getResourceAsStream(“build.xml”);
File tempFile = File.createTempFile();
copy(is, tempFile);

ProjectHelper.getProjectHelper().
parse(project, buildFile);
 
// set properties
project.setProperty("to", "World");
 
project.executeTarget("sayHello");

A few caveats still remain:

• The project.init() is expensive. If possible, you only want to do this once per build file.
• The ProjectHelper.getProjectHelper() method does not yet take an InputStream as an argument. The source code appears to allow you to write a plugin that would support this, but I took a simple approach. I read the resource from the jar and copy it to a temp file.

In summary, Ant has proved useful as an embedded library. However, what I noticed most was that Ant not only provided a robust solution, but also enabled other features that would have otherwise not been considered.

In Embedded Ant, Ant
Comment (2) Read More...

AUSTIN, Texas — July 21, 2008 — Phurnace Software, Inc., the Java application deployment company, today announced that it has completed its $5 million Series A financing, led by S3 Ventures, a Texas-based venture capital firm. Previous investors, including DFJ Mercury, also participated in the financing. The capital will be used by Phurnace to expand sales, marketing and development activities for its patent-pending deployment automation products.

The company provides IT operations staff with data center automation tools to dramatically reduce application deployment times, decrease configuration errors, lower costs and enable more efficient enterprise Java deployments. The company’s flagship product, Phurnace Deliver™, is used by some of the country’s largest companies in multiple vertical markets. It supports deployments and automated configurations on the leading web application server platforms, including IBM WebSphere®, BEA WebLogic® and RedHat JBoss™. The company has also recently announced automated deployment support for IBM WebSphere® Portal.

“S3 invests in companies with innovative technology, a compelling measurable value proposition and significant customer traction,” said Brian R. Smith, Managing Director at S3 Ventures. He continued, “Phurnace’s products address a clear need in the marketplace, as evidenced by its use among Fortune 500 companies, and we are looking forward to helping them expand their rapidly growing business.”

“The fit was strong between Phurnace and S3 Ventures because we both see how data center automation is top-of-mind in enterprise IT departments. S3 sees the large investment opportunity in the data center and Phurnace has created a powerful solution to reduce headaches and costs there,” stated Larry Warnock, President and CEO of Phurnace Software. He continued, “Companies continue to invest inordinate amounts of time and effort into scripts and manual processes where automation is a much better approach. The value of using Phurnace Deliver™ can be seen immediately after its installation.”

System administrators and Java developers use Phurnace’s technology to reduce errors, save time and eliminate the need for hard-to-maintain scripting while configuring web application servers. The use of Phurnace software results in a significantly more efficient deployment process which can be shortened from weeks to minutes. The agent-less architecture of Phurnace Deliver™ fits into companies’ existing data center processes and the command line interface (CLI) option allows for direct integration to software build and operation toolsets such as HP Server Automation®, IBM Rational®, IBM Tivoli® and BMC BladeLogic™.

About Phurnace Software, Inc. Phurnace creates software that troubleshoots configuration problems and accelerates deployments of Java EE applications. It eliminates the error-prone, repetitive processes and headaches associated with troubleshooting, configuring and migrating of software running on web application servers -- regardless of vendor or version. System administrators and developers use Phurnace to eliminate errors, save time and reduce overall deployment costs. www.phurnace.com.

About S3 Ventures S3 Ventures is an early-stage venture capital firm investing in companies which address large market opportunities in the information technology and medical device sectors. We invest primarily around the Southwest with a focus on Texas. Our offices are located in Austin and Houston. S3’s team is a group of seasoned investors and successful entrepreneurs who have repeatedly built companies into great returns for investors. At S3 today, we help talented entrepreneurs take their technology and market knowledge and form valuable businesses in a methodical fashion. For more information about S3, visit http://www.s3vc.com/.

Phurnace and the Phurnace flame logo are trademarks or registered trademarks of Phurnace Software, Inc. in the United States and other countries. All other names are the trademarks or registered trademarks of their respective companies.

###

In phurnace
Comment (0) Read More...

As you may, but probably don't know, Phurnace got some Phunding. The management team put in countless hours over the last several months and the process was apparently fraught with twists and turns that would give Gordias pause. Thankfully, our fearless leaders didn't share with us each and every bump in the road. Even more thankfully they didn't share with us those moments, of which I'm sure there were a few, when the road disappeared altogether. I'm a lot like Bill Paxton's character in 'Aliens': I talk a good game and will bust my butt until the bitter end, but am real quick to loudly proclaim "Game Over, man!" when things don't go as planned. Knowing too much would give me fits.

When it comes to spending someone else's money, I think a lot of software companies screw up by making financial choices like the Lohans' make parenting decisions. Instead of worrying about their employee's productivity and professional growth, they want their employees to think their job is cool. Instead of laying the groundwork for long term success, they try to compete with the outrageous perks offered by companies like Google. Don't get me wrong. Fully stocked break rooms, expensive chairs, and ping pong tables are nice. And even though I'm as pale as they come and have a history of skin cancer, I love a good beer bash on a party barge just as much as the next guy. But I would not trade quality hardware or capable new co-workers for any of these fleeting perks. Good employees don't join a company for the parties or bottomless soft drinks. They join a company because they believe in it's products, are optimistic about the company's success, or are intrigued by the professional growth it offers them. The ones that get caught up in the perks are usually the first ones to leave when something new comes along or complain when the company hits leaner times and has to cut back on the cool stuff so they can make payroll.

The culture here is based on honesty and openness. So while the nitty-gritty of start-up funding wasn't revealed to us there has been a lot of discussion of the funding process. The chickens were never counted before they hatched, but we sure did make a lot of plans for exactly how we were going to count those chickens and what we were going to buy with our new found...poultry. O.K. I think I've lost control of the hatching chicken metaphor. Anyway, during these discussions on what was to be done with the funding it became clear to me how much different Phurnace is than some of the other start-ups I've worked at. The coolest thing about this company is that everyone here seems to be in agreement with the long-term plan. By opening up discussion of business decisions to all of us, it's easier for us to see, appreciate, and contribute to the company's growth and success. It's also striking that everyone can now rest assured that a dime is not spent without tracing it back to a concrete benefit for the company. We are making quality hires and investing in an infrastructure that will optimize productivity and yield solid deployment solutions that we can not only sell, but also take pride in. And isn't building something new and cool what working at a startup is all about?

In phurnace
Comment (0) Read More...

To a non-geek, spending a weekend in hotel conference rooms listening to presentations on the latest technologies in software development might make them beg, "just shoot me now, please". But to someone interested in keeping abreast of these sorts of things, for both company and personal reasons, it was a very nice way to do just that. Plus, it was hot as hell outside, the neighborhood pool is even hot, and the lake is just too far away.

The Lone Star Symposium was held this past weekend here in Austin, and it was a great show. The lack of vendor presence at these conferences allow software developers to focus on the technology itself. The people who put this conference together go out of their way to provide all the amenities to the attendees, such as good food, snacks, not to mention some of the best industry experts out there. With regard to the experts, I am always pleased to find not only those who write about the technologies at this show, but also those who have had a hand in developing them. A case in point, the presenter for the Spring Framework was Keith Donald, one of principals and founders.

It's always a shame that you can't make it to all the sessions in this type of conference, but you generally can't go wrong with any selection. Just to sort of sum up, the hottest topics this year were the ones concerning dynamic languages, such as Groovy, and it's related framework, Grails. Also, Spring continues to be THE overarching framework for J2EE development.

My favorite session, though, was one by Neil Ford, titled "Productive Programmer: Acceleration & Automation". I am a sucker for cool command line tools, and he talked about such great productivity enhancers such as Auto-Hot Key, which allows you to define (and redefine) hot keys in Windows, and clcl, which allows you to maintain multiple clipboards. I am very keyboard-oriented, and these tools will allow me to stay away from my carpal-inducing mouse.

Next time one of these conferences makes its way near you, check it out. Especially if its a hot summer weekend!

In Spring Framework, Groovy
Comment (0) Read More...

Recently, I was entertained by hearing complaints from a friend regarding their Agile practice and how impractical and inefficient it seemed. This conversation led me to think about our own agile practices at Phurnace and other companies for which I’ve worked. It is my experience, since the Agile boom, companies tend to adopt a hybrid approach that is typically a collection of agile practices mashed up with traditional practices from which people feel comfortable. I reviewed some of the basic principles of Agile software development and found several common pitfalls.

Individuals and interactions over processes and tools

Agile projects are geared to expect change. Agile practices expect that management, sales, and product leadership frequently change project requirements. Recognizing this as a reality rather than denying it leads to a more honest and accurate approach for your organization. Thus, agile projects must explicitly abandon traditional planning in favor of direct interaction with individuals. With a clear focus on high value features and releasing valuable software often, a software team can adapt to frequent changes yet consistently deliver additional product "value”.

Traditional team management use tools such as Microsoft Project to breakdown work items that look into the project's future. Resources are allocated, dependencies are tracked, and tasks are mapped to individuals. This plan is traditionally managed by identifying the "critical path" for final delivery. Any change or diversion from the plan forces the plan to be re-worked. If the project has little variance, this approach is effective. However, most software projects change often resulting in making the project plan irrelevant.

One pitfall is that most hybrid approaches continue to use traditional tools to chart out a project plan which only confuses the leadership. These estimates are put into a Microsoft Project chart to determine which stories are feasible for the next iteration. This piece of planning, even on a smaller scale, is often out of touch with reality. The reason lies behind the estimates. A spreadsheet or Gant chart of numbers fails to communicate many of the inferences and risks that would otherwise be learned by direct interaction with the team members or the lead. In essence, given a 3-4 week timeframe, relying on your team's depth of knowledge and experience thru personal interaction is a better measure for the feasibility of tasks.

The second pitfall with this theorem is around processes. Adding unnecessary processes under the name of “Agile” is, in my experience, the most abused part of the practice. For instance, daily or frequent standup meetings are very effective for encouraging frequent collaboration and communication between your team members. However, if the traditional “weekly development meeting” is simply expanded to a “daily development meeting”, it only achieves 5 times more wasted time.

Working software over comprehensive documentation

The most important thing in a software organization is consistently creating software that provides value. Frequent collaboration with your collegagues often replaces the need for short-lived documentation. Rarely, does an internal design document or test plan add value to a product suite; while actual development or test execution can produce another valuable release.

The pitfall often found in a hybrid approach is not usually around typical documentation such as test plans for design documents. Instead, organizations adopt traditional practices such as weekly status reports and require so-called-Agile “daily” status reports. Daily status reports are just another form of comprehensive documentation leaving less time for working on software!

I am sure many people experience issues with Agile development while also seeing huge improvements over the traditional practices. I am very interested in hearing any feedback or opinions. In a follow-up blog, I plan to address the other two theorems:

Customer collaboration over contract negotiation
Responding to change over following the plan

In Agile Software Development
Comment (0) Read More...