Software quality is much like health: while its presence is rarely appreciated, its absence is immediately visible and frowned upon. There are many concepts of what quality software actually is, but the most general definition can be as follows: quality software is a bug-free, functional and maintainable product, delivered within budget and on time.
Outside and Inside
It may be tempting to judge the book by its cover and to evaluate the quality of a piece of software just by the quality of its interface, but there’s much more to it. Broadly speaking, we can distinguish two aspects of software quality:
Functional: it describes how a product complies with the specification and how useful it is. This aspect is especially important for end users.
Structural: it evaluates the technical side of a product, such as maintainability and code quality. This aspect, in turn, concerns the developers.
_Software quality has two main focal points: end users and developers._
At LiveChat we’re in endless quest for boosting the quality of the product that we deliver. The list below is by no means comprehensible, as we’re constantly discussing the ways of improving our quality assurance process. However, it will give you a glimpse inside our modus operandi, and if you are a developer, it can serve as a quick checklist for your own quality tests.
For easy reference, the list consists of two parts mirroring two aspects of software quality: in use (functional) and internal (structural).
In Use Quality
Functional quality is vital for end users, who expect a product that simply serves its purpose. We can further divide functional quality into the following components:
Functional software is usable, solves an existing problem and does what it promises. Moreover, what is especially important for the owners and stakeholders, it meets the business assumptions and legal requirements.
Needless to say, usable software is available for end users (i.e. it’s on the market) and as easy to learn as possible. Quality software should provide good user experience in terms of intuitive interface, clear workflow or user journey and (as we buy with our eyes and emotions) attractive design.
The users have to be sure that a piece of software is safe, efficient and reliable – nobody likes application crashes, blue screens and lost progress. Quality software has as few bugs as possible, is stable, bullet-proof and has high uptime. Moreover, it should come with a good customer support – the users should never be on their own if something goes awry.
A good and reliable product stems from a well-planned development process. At LiveChat we always make sure that the code we write is top-notch by following a set of basic principles:
A good piece of software is flexible, which means that it’s possible to add, modify or remove functionalities without damaging the whole system. It should be adaptable and scalable, that is it should be possible to re-use its code in other projects of various sizes. An effective way to achieve this is writing modular code whose building blocks can work independently and be easily transferred to other environments. Generally speaking, a good code is a well-though-out one, created with a broader perspective and possible further development in mind.
Creating a product is one thing, but maintaining it and keeping it in good shape is a whole different story. The secret of easily maintainable software is making the code logical, structured and coherent. The code should be minimal and have minimal dependencies; avoid obsolete functions and excessive number of classes. And, of course, all features and functions should be well documented and the project’s version number and changelog should always be up-to-date. All this makes the code more understandable so that it’s possible to easily transfer a project from one developer to another. KISS and DRY!
To provide the best user experience by delivering a stable and reliable piece of software, both development and quality assurance teams should go the extra mile to thoroughly test the product and make sure that if something goes wrong, the damage will be minimal. Efficient error handling mechanisms, both for developers (from good ol’ printing errors to the console to advanced analysis tools) and end users (clear and meaningful error messages) can greatly facilitate the testing process.
In the context of software quality, efficiency refers both to the code and to the development process itself. The code should be well-optimized for maximum speed and performance and the developers should use automation tools such as CI, linters and static code analysis to facilitate the production process.
The Path to Perfection
While it all sounds great, producing quality software is a never-ending road. It’s all about designing, developing, implementing and adjusting the processes facilitating the quality software development. At LiveChat we follow a set of good practices to stay on track:
A good plan is half a success. It’s vital to define the scope and make a plan before starting a project and to do a research and design a solution before implementing it. While working on each sprint or iteration, the team has to have full knowledge of the requirements and a clear idea of what they actually want to achieve, and then they should stick to the plan within this particular iteration (which also applies to consistent selection of tools and methodologies). Also, when planning a project, it’s necessary to keep a realistic balance between the final touches and the delivery date, as none should suffer at the expense of the other. A good technique is releasing the minimum viable product to testers and early adopters to get user feedback as soon as possible.
As far as more elaborate pieces of software are concerned, it’s no good to work alone. We always try to have the developers work in teams so that they have a second pair of eyes to evaluate the code and somebody to brainstorm with when they need it. What is important is that the teams themselves are autonomous and work independently.
Even the best developers won’t make full use of their potential if they don’t communicate with their colleagues. Each project should be fully transparent and all team members keep each other updated about its architecture, procedures and progress. Every person involved in the project should have the right to express their opinion and to move the needle on the solutions.
To have a cookie and to eat it, too
Like there is no single best definition of software quality, there is no ultimate recipe for a good product. Considering the functional and structural aspects of software quality helps broaden our view, but it’s important to keep in mind that more often than not it’s necessary to make trade-offs between the competing goals. The characteristics of quality software should be defined for each project separately, considering project type and its intended usage as well as the aims and objectives of all parties involved (stakeholders, developers and end users).