It is a known fact that applications must change to meet changing business needs. Most software development companies, large or small, face serious schedule risks from these recurring problems:
* Excessive “drag” from existing applications,
* Late discovery of defects, when their repair is most expensive,
* Unpredictable integration and QA cycles that delay application delivery
* Schedules met only through disappointing sacrifices of functionality and quality.

The root cause of these problems is that the code making applications are fragile. Usually just 20 percent of an application’s lifetime cost is in creating it. But useful applications are regularly built from fragile code, making the 80 percent spent in maintenance and enhancement quite painful. It’s easy to release fragile code that works.

The solution could be developer testing also known as unit testing. This is an effective idea that improves time-to-market, quality, and flexibility. The key idea is that each piece of code needs its own tests and the best person to test that code is the developer working on it. Enabling developers to test their code as they write it ensures that quality is built-in from the start. Having unit tests makes it easier to modify the code because the tests document and protect the intended behavior and will instantly catch any regressions.

A good developer testing automation technology helps build code and the team. The technology should be able to show the risk associated with each of the Java applications and create tests that help safely simplify complex code. One can cut up to 50 percent the time a software team spends fighting with existing applications. Delivery of new applications can be made 20 percent to 30 percent faster (with few bugs). Also 90 percent of software defects that reach your QA and integration teams can be cut and there can be a 90 percent reduction in the the cost of detecting and fixing bugs after the software is released to customers. These savings can add up to millions of dollars per year for even a medium-sized software development company.

We had the privilege of working with one of the largest online book marketplace for new, used, rare, and out-of-print books. Some of the major critical issues faced by the company were:
* The e-commerce dilemma: The more popular the site, the heavier the load on systems and the larger the impact of even subtle failures.
* Site downtime: Costing the company as much as $150,000 a month in revenue loss.
* Customer satisfaction: Each and every error threatens business relationships with booksellers and consumers.
* Quality ownership: No clear ownership of QA and quality, causing friction at all levels within the organization.
* Legacy code: Team of first-time coders hesitant to identify—let alone test—earlier work.
* Confidence: Management losing confidence in the IT staff and its ability to fix IT problems and restore lost revenue.

The loss in revenue created internal friction between company’s development and QA teams. At this stage the company decided to formalize unit testing and make this the cornerstone of the company’s quality transformation. To accelerate the transition to unit testing, company website developers started using open source JUnit and began working with Agitar. Soon, with the help of Agitar’s automated testing tools the client began to look at the code much more objectively.

The author is Country Manager of Agitar Software Solutions. He can be reached at vishnu@agitar.com