The blog post this month is going to be a bit different from the others I have done. This is because my research covers two main areas which are aspects of ADHD and other disabilities, and how we use technology and software. So, this post is more about the technology side of things, and about how important it is to keep users in mind when building software, as well as a few tips on how to do that.

When it comes to software development, there is usually quite a universal life cycle that will be followed. There are variations, but the basics tend to be, a client will have an idea for a product, and a list of requirements. The developer after discussing things with the client, will then begin a process of building, testing, and correcting, on repeat until the product is ready for the client.

However, one of the issues that can come about in this process is developers getting stuck focusing on meeting the requirements regarding purely the functionality. While this may not sound like an issue, it can be when the entire focus gets placed on the software being able to do something, without any thought for how it is used.
An example could be if someone asks you to make a door that lets you into a building, and then a door is made that only opens from one side. While this does technically meet the criteria set out in the request, in reality, it won’t be usable for someone who wants to get back out of the building. Software design is similar, in the sense that you can satisfy the requirement, and still have something that isn’t usable, the main difference being that it can be harder to spot the situations when something isn’t quite right.

This can lead to situations where a developer finishes a project, only to be told there are issues that need fixing that weren’t anticipated. Because of this, it is important to realize that making software with users in mind isn’t just beneficial for the user, it also actually benefits developers by anticipating needs the client may not have thought of when creating their requirements. It can also help developers to understand how to structure their products by anticipating how they are likely to be used, so what layout would make the most sense, and what features would be used most by a specific target audience.

Now keeping users in mind is easier said than done. Even a team of developers can’t anticipate the needs of every single user that may end up using their product. So here are a few techniques that can help when designing software to at least catch some of the issues before they get flagged by users.

UI (user interface) sketching / wireframing:
This method involves basically making a draft of the user interface that would be part of the end product. By doing this at the beginning of the process it helps developers catch issues early on, and also helps give a better goal to be building towards. It can also work well to help with one of the other strategies I will share. There are many ways to wireframe, ranging from software that can create interactive interfaces for you to manually navigate, or just using pen and paper to help plan a layout, either one can be helpful to a developer trying to anticipate the usability of a product.

Requirements as scenarios:
Another technique that can be helpful, especially when coupled with wireframing, is turning requirements into scenarios using story boards. Creating a mock UI, and then using it as a user would, can help you identify roadblocks. This could be something major such as realising your product would need to include user accounts to be used optimally, or something minor such as including a dark mode to help reduce eye strain. All of these things are best worked out by using a mock product, which leads us nicely into my final tip.

Multi-purpose bug testing:
When a developer finishes coding, the most important stage can begin, bug testing. This is when a developer is looking for issues or broken code that might impact the functionality of a product. However, bug testing can serve a secondary purpose, usability testing. By simply shifting mentality slightly, you can have an additional function in the most important stage by not only looking for things that break the product in a sense of functionality, but also in the sense of usability. By using bug testing as an opportunity to use the product as a user might, it gives you insight into the user experience and how the user will feel using your product. It can also be important to make notes not just on broken functionality, but even little things such as when bits of the system are annoying to use, so you can later address these issues and deliver a more pleasing product.

So, in summary, usability is a fundamental aspect of software development, as no matter how sophisticated someone’s product is, it is no better than something that doesn’t function if it isn’t usable to your target audience. And one of the most important things for a developer to do when building a product, is communicate with the client, and ideally, potential users or testers to get an outside input on the product they are making. I hope these tips will be helpful, and the topic has been interesting to anyone who has any interest in software development.