What it takes to make great software
15 September 2020
Read time: 5 minutes
Creating great software is a balance between multiple perspectives where favouring one perspective may be detrimental to another perspective. To add further complexity, these perspectives will vary depending on the project, the organisation, the team, or even the day.
That said, there are a number of attributes to writing great software that are common to most perspectives, they are as follows:
Software should meet user requirements.
This may sound straightforward, but it can be more challenging than it appears. Users sometimes ask for more functionality than they need, and they don’t always ask for things that they do. Good software should meet essential functionality as needed by the user (even if not requested) both immediately and for the foreseeable future.
Software should be as bug free as practically possible
Software bugs are never created deliberately. Equally, no software of any complexity is ever completely bug free. Bugs take time and cost money to fix. The compromise of bugs verses time allocated to fix them will ultimately depend on the software application. For example, you would hope that the software used in an aeroplane autopilot has very few bugs.
Software should be both testable and tested
To ensure software meets user requirements and has as few bugs as possible it must be tested and written in such a way to make that testing as efficient and exhaustive as possible. Where possible, tests will be automated but there is usually some human intervention needed for testing most software applications. There will always need to be a pragmatic trade off depending on the nature of the software.
Software should be maintainable and modifiable
Software can be around for decades and during that time it is likely that changes will need to be made to the software e.g. to add new functionality, to fix bugs, or address software security vulnerabilities. Using agreed software practices (e.g. coding standards), clear documentation, and creating software in small self-encapsulated modules (so that a piece of software can be changed without impact to the rest of the system) will all support easier changes to the software.
Software should be secure
There are a lot of attempted hacks against any software that is exposed to the outside world. These attempted hacks only need to be successful once to potentially cause great harm. Software needs to be as robust as possible to prevent these hacks from happening at all, or if they do, minimising the damage that is caused as a result. New vulnerabilities are exposed every day and software must be continuously evolved to maintain security robustness.
Software should meet non-functional requirements
As well as performing functionally and doing what the user needs, software should meet other requirements. E.g. it should start and operate quickly, it should operate smoothly on a variety of different hardware and operating systems, and work with multiple versions of browsers etc.
In addition to the above, in order to create great software there are a number of other higher level considerations:
- Software delivery projects should align closely with business strategies.
- The right people are essential to make up a high performing software delivery team and must have good soft skills to underpin their technical skills.
- The purpose of the software (i.e. user requirements) must be clear. Ideally, Software Developers will have direct access to talk to the end user(s).
- The right tools must be available to the software delivery team. Tools to improve both quantity and quality of software development are constantly being developed.
- Software Delivery is not just the remit of the software delivery team. Regardless of whether the deliverable software is the organisation’s product, or it is just a tool for internal use, other stakeholders within the business should be part of the overall delivery pipeline.
- Software requirements can and will change. It’s crucial that an agile software approach is used that embraces change without impacting quality or quantity of the software deliverable.
To conclude, whilst there is no magical formula to ensure that great software will always be produced, taking into account all of the above when developing software will make a significant difference to how great the delivered software is!