Testing & Debugging Blog

Monstrosity

Thu, 23 Aug 2007 12:45:40 -0500

Well, it would stink to work in either the PR department or the software development department at Monster.com right about now. The Infostealer.Monstres Trojan that was discovered attacking the job seeker site late last week just keeps sounding worse and worse. Bad enough that the malicious code collected 1.6 million records containing e-mail addresses, phone numbers, addresses and resume details of job seekers, but now the clever boys and girls at Symantec have figured out what the bad guys want to do with that information.

Bug Puzzles

Tue, 05 Jun 2007 13:51:48 -0500

Longtime readers of DDJ will no doubt recognize the name Jim Gimpel. Gimpel Software has, after all, been running its "Bug of the Month" ads in DDJ for sixteen years. Each ad presents a concise description of a code gotcha that compilers won't catch. It's all to sell Gimpel's software, of course, but the ads are popular among readers. Jon Erickson chats with Jim about the phenomenon.

Lightweight Code Review

Tue, 22 May 2007 14:17:49 -0500

Sometimes the key to finding more defects is simply to review more code in the time available. To do this, you've got to keep your reviews light. Formal code review can be very time consuming, which makes peer review an attractive prospect. Jason Cohen of Smart Bear Software makes the case.

No-excuse Testing

Tue, 08 May 2007 13:08:44 -0500

Despite the obvious benefits of the various forms of developer testing, it's still not the norm in most software development projects. The reason why, according to Agitar Software's Alberto Savoia, is what he calls "resistance to test infection." Basically, some of us have the testing gene, and others don't. But that doesn't mean we can't improve our utilization of testing methods. According to Alberto, it basically boils down to "some testing is better than no testing." We talked with Alberto recently, and here's the interview.

Making Change Management Work

Tue, 24 Apr 2007 13:12:44 -0500

Change management is one of those tasks in software development that really comes down more to social engineering than software engineering. The core of the task is prioritization—deciding which bugs to fix first, or to fix at all before the next release. But this decision process is fraught with conflicting human perceptions—namely, what constitutes a "critical" bug. Your best bet to make it work harmoniously is to get everyone on the same page. Francisco Torres gives some good advice on doing this in his article "Change Management and the critical+++++ Anomaly."

Release Right

Mon, 09 Apr 2007 12:42:28 -0500

If you're doing things the Agile way, you know that the release phase of a project is not the time to do your major testing. That should be done throughout the life cycle. But that's not to say there's no testing at all at this point. It's just a different kind of testing. Scott Ambler explains.

You Need a Speedy Debugger

Mon, 26 Mar 2007 13:34:57 -0500

Debugging is a huge time investment for most development efforts. To reduce the percentage of overall development time spent in the debugging effort, you want your debug tools to perform. What governs the performance of a debug tool? It's all about memory access. Green Hills Software's Anderson MacKay breaks it all down for you in his article "Debugger Performance Matters: The Importance of Good Metrics."

Low-level Familiarity

Tue, 13 Mar 2007 17:29:08 -0500

For the sake of productivity, we love to have tools and technologies that insulate us from the low-level implementation details of our projects. But as Ed Nisley points out in his column, there's really no substitute for understanding the details of your underlying hardware and software platform.

Multicore Bugs

Tue, 27 Feb 2007 12:53:30 -0500

When you need to debug an application that is split across multiple CPU cores, you face some special challenges. For one thing, there's the debugging equivalent of the Heisenberg Uncertainty Principle: The act of observing your app alters its behavior. This only gets worse when you're dealing with multiple cores. Intel's Julien Carreo discusses this and other issues in "Debugging Asymmetric Multi-core Applications: Part 1."

Makefile Mayhem

Tue, 13 Feb 2007 12:45:08 -0500

GNU Make, despite its widespread use, is not the easiest language to debug. If you've been trolling through the output of make -d to track down problems in your makefiles, you know the frustration. With the use of a few clever hacks, however, you can reduce this headache dramatically. John Graham-Cumming tells you how in "Debugging Makefiles."

Avoid Entanglements

Tue, 30 Jan 2007 15:18:56 -0500

The concept of tight coupling, where one depends on a knowledge of the internals of another module, is a sin that will cause most compilers to choke. But what about when the compiler knows nothing about the coupling? Well, what you have there is "Insidious Tight Coupling." Bil Lewis outlines the perils in his article.

AJAX Debugging? Yes, Please

Tue, 16 Jan 2007 14:42:18 -0500

When your app is built from disparate technologies, as are AJAX apps by definition, debugging is always hard and time-consuming. Any tool you can get your hands on that tames the confusion is a welcome addition to your arsenal. So it is that AJAX developers everywhere will undoubtedly want to give Joe Hewitt's free Firebug extension a look. Joe describes debugging with this AJAX IDE in "AJAX Debugging with Firebug."

Testing WiMAX

Tue, 02 Jan 2007 15:18:56 -0500

The WiMAX standard is a behemoth: adhering to it means complying with 900 pages of documentation describing the physical layer and the media access control layer for WiMAX systems. Obviously, this calls for some sort of rigorous, frequent, and automated testing solution. One option is to build an executable specification.

The Static Ideal

Mon, 18 Dec 2006 14:42:24 -0500

In Jon Erickson's recent interview with Mike Laginski of Clockwork, Mike raises the very real, and in my mind somewhat troubling fact that programmers are increasingly expected to practice, as he puts it, "a science, not an art form." I don't dispute this, and frankly, under that pressure, static analysis tools can be a huge help in nailing down defects early. At least, it certainly feels like you're practicing more science than art when you are doing automatic testing against some hard-and-fast rules early in the development cycle. And I'm all for taking as scientific an approach as possible. I suppose the question is this: "where are the limits of the scientific approach in software development?" I mean, we are, ultimately, talking about an act of creation. It's the "artful" nature of programming that drives managers and business types nuts, because it's precisely this intangible monster that forces delays and cost overruns. But it can't be factored out.

Testing Agility

Tue, 12 Dec 2006 16:38:28 -0500

One of the key components of Agile development is testing. Agilists test early and often, and frequently first. In "Agile Testing Strategies", Scott Ambler shows how Agile testing involves two kinds of testing: confirmatory and investigative.