Software flaws can be avoided

We don’t always do what we know we should do, and this is especially true of the software development industry, where producing buggy software has become almost acceptable practice.

The poor quality of software is largely a cultural issue, said James Governor, an analyst at Nashua, N.H.-based Illuminata.

“There’s a lot of cultural change required to improve software quality,” he said.

Terrence Regis agrees. A lot of critical errors could be avoided if developers took the time and effort to do things properly, said Regis, the software assessment and release director at Conshohocken, Penn.-based Synygy Inc., which creates enterprise incentive management software.

“One of the main reasons that some of these things aren’t avoided is because of time,” he said.

Often, the rush to market and the desire to be the first out of the gates with a new product or snazzy new feature results in taking shortcuts, he said. As a result, a lot of good policies and procedures fall by the wayside. Companies believe being first to market will help them gain market share, and that addressing errors that might creep in as a result can come later, Regis said.

This is acceptable behaviour in today’s market because consumers don’t speak out against buggy software, Governor said. A consumer would never accept a car built with the same standards that went into their desktop, he said.

The key to writing clean software starts with the requirements definition and design, Regis said. Defining requirements should never be done in isolation by the requirements analyst, he said. Rather, the requirements should be defined by a cross-functional team that consists of developers and a client representative. This allows issues to be raised early in development, he said.

Paul Winterhalder, the vice-president of product development at software development outsourcing company bitHeads Inc. in Ottawa, agrees with Regis that good software begins with properly defined requirements.

“Far too often, the requirements are not understood, so if they’re not understood and communicated back to the customer, no matter what, your project is going to be a failure from the get go.” Getting customers to sign off on requirements and developing user interface prototypes are two ways of avoiding errors at this stage, he said.

And when defining requirements, it’s important to remember that the system may need to interact with another system. Sometimes, only functional requirements are defined, Regis said.

Also, when designing a system, it’s important to keep it open to change, as the requirements might change, or the client might decide that it needs to support a different database or platform, Winterhalder said.

“You have to make sure your architecture will allow for those changes in the future.”

Testing is another key to avoiding buggy software, and it needs to be done at every level – unit, integration and system, he said. Synygy, for example, does three types of unit testing It tests for coding standards, with the help of a tool created by Parasoft, and it does white box and black box testing, he said.

When testing, it’s important to have separate development and test teams, Winterhalder said.

“Developers are terrible testers, because they know the way the system is supposed to work.” They don’t test software properly, because they think no one will use the software in certain ways. “But a good tester doesn’t follow the instructions on how it’s supposed to work,” Winterhalder said.

The other problem is that a lot of people using the waterfall approach leave testing till the end, he said.

“That is a terrible thing because you don’t find out until the final 25 per cent of the project that you have significant bugs in the system that may cause you to redesign the whole system.”

To avoid this, bitHeads constantly releases software to its quality control department as an application is being developed.

Another problem that many projects face is lack of proper prioritization, Winterhalder said. The problem is, many developers want to do the really cool stuff first. But those should be left till the end, as they often fall into the nice-to-have rather than the need-to-have category. Developers should always begin with the must-haves, he said.

Java can help in the process of avoiding errors because it has automatic memory management and garbage collectors, said Juergen Dingel, an assistant professor at Queen’s University in Kingston, Ont. It’s very easy to forget to free memory you don’t need any more, he said.