An overview of the core requirements
A lot of different factors affect what a good piece of software is, including it’s intended purpose versus what it actually ends up getting used for.
However, there are some key things to do when developing your software that ensure it is up to scratch:
- Good software is functional. If any piece of software isn’t able to execute its core functionality then it’s useless. Always make sure that you have a product outline in place that describes its intended function, create a roadmap that supports that, and always refer back to both when you are looking to make changes. Does your change fit in with the functional requirement of the software? If the answer is no, forget it!
- Good software is robust. It has to be resilient to change – so when you make modifications it is built in such a way that means it won’t just collapse and stop working. It also means being able to recognise and deal with failures (the functionality becomes outdated, or doesn’t fit in with user needs anymore, or won’t work with new technology), so you can make the relevant modifications.
- Good software is measurable. It should be possible to see how well the code is doing outside of a test environment. Usually, the best measures are how the software can facilitate business needs or how well it is servicing the users it was intended for. A good measure for UI for example, is how long does it take to load or react to an interaction.
- Good software is debuggable. This doesn’t mean being able to log everything and anything that the application does (that would not be worth the time investment), but being able to bulk dump debug on demand can be very handy for developers. Helping them get the bottom of any issues much faster than they otherwise could.
- Good software is maintainable. Software can be easy to maintain if it has consistent styling, has thorough commenting throughout (so any developer looking at the code can understand what a particular part does or doesn’t do), has been built with a modular approach and so on. There is also a lot of literature on good software design that focuses on design principles that, if followed, recommend being able to make changes to parts of the software without breaking other parts in the process.
- Good software is reusable. Generalising a solution can be hard and time-consuming, especially when deadlines are tight, but a good best practice is to create functionality that you are then able to use elsewhere in the platform. So for example, you should create a form feature that you can then reuse on other pages / sections of the application, without having to create it from scratch each time. It does take more time to complete in the beginning, but has long term time, cost and usability benefits.
- Good software is extensible. Anyone working in software, be the software client or the development company, is normally very familiar with this conversation. Usually it goes something like this – “but what if tomorrow somebody wants to add X here”. Well that is inevitably going to happen, so software should be written with extension in mind, and these extensions should be thought of in a general way. Take copy for example. The ‘copy’ command on all Mac operating systems functions exactly the same way across all of the software applications installed on it, making it immeasurably more valuable. Imagine having to learn what copy and paste was every time you accessed a different application – so Word has one way and your calendar has another. It would be a time consuming and frustrating nightmare. So plan ahead, and make sure that you have consistency and extension in mind when creating your software.
If you have any questions around planning your next development project, or even around any existing software that you have, then please do drop as an email to firstname.lastname@example.org or call us on +44 (0)800 774 7306.