Building Quality Applications
Quality considerations are of paramount importance in the software business. It has long been understood that the costs of defects rise significantly when they are not caught early. The agile community, for example, refers to “failing fast” as an important rallying cry and, as a result, sees continuous integration and testing as fundamental practices. Regardless of what development tool is chosen (although I hear Visual Studio is a good one; wink-wink-nudge-nudge), it should provide a set of innovations around test and quality to help software teams deliver superior results.
Poor quality software costs an organization an exuberant amount of money and this money is lost through poor productivity and wasted resources, with the majority of the pain being felt not by the development team but by the end users. Once at this stage then having the business “buy-in” of thinking I.T. as a valuable partner is lost and contention begins.
Project success is defined using the project management triangle (time, cost and quality). In the software world we often replace the quality constraint with features, functionality or scope.
In fact scope, features and functionality are all intrinsic parts of the quality of the application, because, at the end of the day, the only measure of quality that matters is whether or not the customer is happy with the final product.
In concise terms this generally means that the product does what the customer wants (provides greater efficiency and effectiveness in their daily work) and it is free of defects
which detract from the usefulness of the software.
It is commonly accepted that you can only optimize for 2 of the 3 axes of this triangle so you always end up making a tradeoff between them in order to deliver a successful solution. There is no single silver bullet to help you make these tradeoffs, but organizations can help themselves by using tools and processes that give themselves the best chance of avoiding project failures.
The path to any successful solution is a long and winding road with many challenges along the way. From initial idea to eventual solution the challenges can be numerous and varied.
There are many reasons why projects are challenged but two issues that are consistently at the forefront are:
Estimation – Over half of the projects started will cost almost double their original budget. These cost overruns make the whole process problematic and may result in projects being cancelled.
Scope Management – Large projects typically only deliver a little over 40% of features that they originally planned (but that does not mean they have not added more features or spent loads of time on the 60% of features they did not deliver writing specs etc.).
When you look at the macro level it tends to be associated with value and predictability:
Predictability – On top of general estimation, providing feedback loops into the process that allows directional changes and making the right decisions is crucial but rarely put into practice.
Value – Building the right software is massive. Most organizations do a very poor job of deciding what software to build and if doing X is more important than Y.
3 Components to Achieving Quality
There are 3 components that can be employed to alleviate many of these problems and put an organization on the road to success. These are:
1. Good design
2. Being able to share that design
3. Integrated architectural diagrams
Today, many architecture tools and critical modeling diagrams are separate from the development, requirements and testing tools. This makes it extremely difficult to architect systems so that the architecture is not discarded or ignored once coding begins. Developers have to constantly refer to other documents or other tools and eventually they just don’t. The side effect of this is that the design becomes out of sync with the actual code and traceability is lost at the technical level. This has an impact on the maintenance of existing systems as well. If you can’t understand the system, then maintaining it is difficult, if not impossible.
Bug and Code Management
Finding bugs is always better during the development phase then after the application has been deployed to a production environment. Therefore, bug tracking, resolution and traceability should be implemented. Features such as static code analysis can also be used to provide insight into where there may be potential issues before they become a problem. Shown below is Test Manager 2010 - Testing Center.
Code metrics (i.e. maintainability index, cyclomatic complexity, depth of inheritance, class coupling, etc.) should also be performed which will allow developers to determine where their code is most complex and possibly simplify it. A sample of this is below using Visual Studio 2010's code metrics utility.
Along those same lines, a comprehensive performance testing tool will help ensure that the application performs as required and meets all expectations. This is extremely important as the application may appear fast, stable and free of defects (within a developer’s local workstation) when in reality this couldn’t be further from the truth once the load increases exponentially.
Quality is everyone's responsibility. Whether you’re a developer, tester or end user, everyone on the team should be concerned with developing an application that adds value and is superior in every aspect to the current system (if applicable).
There’s no doubt that every development team approaches each project with one goal in mind – to produce a quality application (if they don’t then they’re doomed for failure). However, that goal can be difficult to reach without the right supporting tools, process and plan. If all of these items are implemented correctly then the completed system from application architecture through development (including test and maintenance) will be of the highest quality.