13 February 2009

Using virtualization to improve quality and shorten QA time

Michael O'Leary at Robert Half Technology asked me to speak to some of their clients on virtualization and how it has helped me in my QA efforts. Here are the handouts and slides:
I used a variety of online resources to prepare for my presentation:

Introduction
Resources
x86 Hardware Support for Virtualization

Virtualization Providers
(extremely abbreviated; see http://en.wikipedia.org/wiki/Comparison_of_platform_virtual_machines)
Automated Testing Tools
Continuous integration (Hudson): https://hudson.dev.java.net
Technical debt: http://sonar.codehaus.org
Automated testing: http://wtr.rubyforge.org/ http://seleniumhq.org/

Cloud Computing
My thanks to Michael, Robert Half Technology and the attendees.

28 August 2008

Criteria for Selecting a Technical Debt Calculator

In "Calculating Technical Debt", I proposed a set of criteria for selecting a technical debt calculator. This list was:
  • Plugin architecture
  • Flexible roll-up rules
  • Current perspective
  • Trend perspective
  • Languages supported
  • Environments supported
  • Supports qualitative data
  • Build environments
  • Custom dashboards
  • Aggregates multiple projects
  • Continuous integration servers
  • User community
To this list I added a few more criteria relevant to using the tools:
  • Tool quality (is the quality calculator buggy?)
  • Latest release (is this project alive?)
  • Documentation (can I figure out how to use it?)
In "Characteristics of Technical Debt", I came to the conclusion that the McConnell internal quality characteristics were well suited to calculating technical debt. His criteria belong on the list then:
  • Calculates maintainability
  • Calculates flexibility
  • Calculates portability
  • Calculates reusability
  • Calculates readability
  • Calculates testability
  • Calculates understandability
I make no claim this list is exhaustive, but it covers enough of the issues important to me that I am comfortable moving forward with it.

In making these evaluations, I need some projects to run through the tools to see how they perform. The obvious choice is some open-source projects. These projects should:
  • Be developed in Java
  • Have their development history captured in a version control system
  • Have high development activity
  • Have JUnit tests
  • Some built with Ant, some with Maven 2
A trip around a few open-source repositories turned up a few likely candidates:

Jena - A framework for building Semantic Web applications. I'll focus on the ARQ component. (Ant)

Jena (ARQ module) has eight releases in its Subversion tags folder:
$> svn ls https://jena.svn.sourceforge.net/svn/root/jena/ARQ/tags

ARQ-2.0/
ARQ-2.0-RC/
ARQ-2.0-beta/
ARQ-2.1/
ARQ-2.1-beta/
ARQ-2.2/
ARQ-2.3/
ARQ-2.4/

Tiles - A Web templating framework.  (Maven 2)

Tiles has eight releases in its Subversion tags folder:
$>svn ls http://svn.apache.org/repos/asf/tiles/framework/tags

tiles-2.0.0/
tiles-2.0.1/
tiles-2.0.2/
tiles-2.0.3/
tiles-2.0.4/
tiles-2.0.5/
tiles-2.0.6/
tiles-2.1.0/
This would seem a trivial matter to pick out some projects to use as a basis for our tool evaluation. It turns out this is not so. I won't bore you with the reasons, but this took WAY longer than I expected.

With criteria and test cases in hand, I'll move on to evaluating the options. Sonar seems like a reasonable place to start.

25 August 2008

Characteristcs of Technical Debt

I was planning to launch into an evaluation of the tools identified in "Calculating Technical Debt" (please read that first if you have no idea what I am talking about), but in preparing for the evaluation, I discovered there are large bodies of work addressing the characteristics of interest for determining code quality. There is even an ISO standard (9126) defining one such set of quality characteristics.

I guess it was pretty naive of me to think that quantifying software quality was a new undertaking. There are five models that appear repeatedly in the literature:
  • Boehm
  • McCall
  • FURPS
  • ISO 9126
  • Dromey
Each model has a different focus and thus includes different characteristics to assess quality (see reference page 38). The following table summarizes these top five models:

Reference: Ortega, Maryoly; Pérez, María and Rojas, Teresita. Construction of a Systemic Quality Model for evaluating a Software Product. Software Quality Journal, 11:3, July 2003, pp. 219-242. Kluwer Academic Publishers, 2003

In "Quantifying the cost of expediency", I proposed using McConnell's "internal quality characteristics" from Code Complete. Does this still hold up in light of these large bodies of research? Lets see.

In a perfect world, I'd take the time research all of these models along with the various hybrids that have been devised. Perhaps I'll formulate my own model one day and become rich and famous. My goal for now is not to devise the optimal model, but rather to create a proof-of-concept for calculating the cost of expedient design and development choices.

From a cursory literature search, it appears that ISO 9126 is the most widely used model. I'll use that as the basis for comparison.

The ISO 9126 standard is summarized by the following graph:

(from http://www.cse.dcu.ie)

As you can see from the graph, the ISO model defines six major characteristics of quality:
  • Functionality
  • Reliability
  • Efficiency
  • Usability
  • Portability
  • Maintainability
Each is further decomposed. Comparing ISO 9126 with McConnell, you'll notice that McConnell is missing characteristics like accuracy and efficiency. He actually presented a separate list "external quality characteristics". These refer to customer-facing issues rather than developer-facing issues. Most of the ISO 9126 characteristics missing in his internal list appear there. Intuitively external characteristics are fundamental to understanding technical debt. They are also more difficult to determine automatically. I am going to choose to postpone including them in the technical debt evaluation for now - it is the expedient thing to do. ;-)

The characteristics on McConnell's list that don't appear in ISO 9126 are flexibility and reusability. These characteristics seem relevant to the technical debt of a project. Flexibility and reusability do appear in the McCall model (see table). McConnell provides the following definitions (p. 558):
Flexibility - The extent to which you can modify a system for uses or environments other than those for which it was specifically designed.

Reusability - The extent to which and the ease with which you can use parts of a system in other systems.
After all this, I am back to where I started. That is not where I expected to be. The original title of this entry was something like "An ISO model for technical debt". It was not until I started comparing ISO 9126 with McConnell that I came to the conclusion that McConnell better serves my purpose.

In the next entry I'll return to looking at the available tools for calculating technical debt.