eWEEK content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.
Are software development errors inevitable or have we lowered our standards on what is acceptable before we freeze the code? The answer is probably a little of both. Given the amount of time and effort that goes into developing patches or deploying service professionals to address more serious issues, you have to ask if some of the issues could have been avoided altogether.
Interestingly, it’s been estimated that addressing an issue that’s discovered during run time can be upwards of 20 percent more than the original development costs. This is because the longer a policy violation or an error is in the application, code or Web service, the greater the probability is that it will be passed along to colleagues and potentially to customers.
So, when you actually stop to think about the “fix it” costs and the associated brand and customer reputation issues, there’s a strong argument for getting the code in its best possible form before the product is considered market-ready and released.
There are, of course, issues such as viruses and hardware failures that affect the performance of the software. However, when it comes to the development efforts, there is room for improvement that won’t result in shipping delays or a mutiny among the development team.
This gap will continue to widen as more products and services are introduced and integrated. And, as the infrastructure continues to evolve, there will be a demand for improved transparency due to the higher likelihood of policy violations and coding errors. These shifts will recast governance in a new light as a proactive, strategic element in software development as opposed to an after-the-fact tactic.
Governance Is Key
Governance is key
Developers and architects alike agree that governance is the primary way that the industry can help stem many of these issues and proactively address them before they get out of hand. Still, even with the best development teams on board, many organizations fall into one of two traps when it comes to employing and enforcing governance to improve the quality of the code.
Trap No.1: The first trap is the belief that they have enough governance.
Oftentimes, governance is applied to separate IT projects that may not immediately have an impact beyond a specific team or division. Yet, with the rise in Web services, cloud computing and service-oriented architectures (SOAs), applications and services that were once dedicated to a small group of users are quickly proliferating throughout different parts of the company (and, in some instances, out to customers and partners).
Trap No. 2: The second trap is the misunderstanding that governance will further delay the software development process, causing product delays.
Upon closer examination, when governance is automated and introduced at the design stage of development, it acts as a background guide to proactively alert developers and architects to when policies are being compromised, as well as to the impact those policy violations and development errors have on the entire company. While a patch or a point release may seem like a quick fix for some of these issues, other issues can have far-reaching effects.
These are the types of errors that are becoming quite common in our daily news feeds. Headlines highlight such errors as the 23 quadrillion dollar debit card charge for a package of cigarettes, or the massive backup at O’Hare International Airport this past Fourth of July, or even the smaller yet equally annoying glitches that interrupt our ability to get our jobs done on time.
You can safely assume that most people have felt the ripple effect of a computer glitch either at work or in their personal lives. Even so, universal acknowledgement should not equate to acceptance on the part of the developer or the customer.
Five Methods to Reduce Errors
Five methods to reduce errors
While malfunctions and glitches have many causes, establishing the best practices and policies to follow as the code is being developed can have a significant impact on the quality of the final software product. With this in mind, the following are five methods to reduce software coding errors:
Method No. 1: Get an aerial view of the infrastructure
You’ll need to understand how your development project can potentially impact different parts of the organization.
Method No. 2: Establish and agree upon the design strategy
Resist the temptation to begin development efforts until the design strategy is aligned with the business goals that the technology is aimed at supporting.
Method No. 3: Enforce policies and encourage best practices
The guidance of agreed upon policies will keep development projects on track and on budget, regardless of where the development team is based. If you then add to this a set of best practices that may be unique to your organization, you will have a powerful combination that will ensure adherence to the processes, as well as inspire new approaches.
Method No. 4: Use governance as a guide
Governance will never fully replace human intellect, nor will it automatically develop the code for you. However, it can proactively identify potential issues, automatically make recommendations, and illustrate their impact on a company. Employed wisely and judiciously, governance can accelerate learning curves and eliminate the unnecessary fear of big brother overseeing every keystroke.
Method No. 5: Build transparency into your infrastructure
As you begin new development projects, make sure you have established policies and procedures in place. This will allow other developers and architects, if necessary, to easily step into a project and understand critical yet basic facts about how the code was written and where the services are located. This will help reduce redundant development efforts, eliminate the reuse of erroneous code and more easily track the cause of an issue.
While you can’t always lead a horse to water when it comes to governance, you can prioritize it as part of the software development life cycle and not just part of a major initiative such as SOA or cloud computing. Along with cost savings gained from streamlined development efforts, governance can help improve customer satisfaction through the sheer ability to deliver products of higher quality.
John Favazza is Vice President of Research and Development at WebLayers. John has more than 20 years of IT industry experience in both public and private companies, with responsibilities spanning software development, research and engineering. He can be reached at john.favazza@weblayers.com.