Tony Aug, Co-founder and CEO at Nimble Gravity, shares his insights on what makes software systems high-quality. When it comes to developing software, it’s not just about writing code that works. The true measure of success is in how well the software system performs in the long run. Whether you’re a seasoned developer or just starting, this post is a must-read for anyone interested in building software that stands the test of time.
As software engineering keeps changing, it’s crucial to think about what makes software systems high-quality. One way to do that is by looking at “-ilities.” These are just characteristics that make sure our software is strong, dependable, and easy to take care of. By making sure our software has these qualities, we can be confident that it’s reliable and works well for the people who use it.
We software engineers didn’t coin the term “-ilities” but we’ve made them a cornerstone of the way we architect and build processes and systems over the years, so we have some thoughts about how we apply them.
At a high-level, an “-ility” is a form of requirement that either has (or which we awkwardly force to have) the -ility suffix. The suffix helps us think about typical requirements in a convenient and memorable way.
Over my years of experience, I’ve come across many “-ilities” that are essential to creating top-quality software systems. In this blog post, we’ll take a deep dive into the 8 “-ilities” that I consider to be the most useful in software architecture:
1. Stability – does the system or process remain working and reliable under a variety of conditions and use. Does It break or spit out weird results in the corner cases? Does it randomly break on its own?
2. Scalability – more work = more problems? How does it handle an increasing workload (maybe users or data or traffic)? Does performance degrade under those conditions? Ideally we understand whether this -ility is an uppy or and outty to borrow from belly button terminology.
3. Usability – is it intuitive? Is it easy and efficient? Are needs and expectations met?
4. Maintainability – updates, modifications and repairs, oh my! Are they easy? Expensive? Can we make them without much risk of introducing new errors or problems?
5. Testability – this ility is to help determine system status. Naturally with this one we talk about QA type testing and the ability to confirm everything looks good before we put something into production. We think more broadly about this though to also include production operation as well (think system status pages and healthchecks).
6. Accessibility – equal access for all, regardless of physical abilities.
7. Explainability – this one isn’t just reserved for data science, but that’s where it most often comes up as in “how and why a model made a particular prediction.” More generically, can we understand the decisions and actions?
8. Extensibility – can we extend (hence extensibility) or modify to add new capabilities (also an -inity!) or features without having to significantly change the underlying architecture. We could also call this one “growability.”
These 8 “-ilities” are just the tip of the iceberg when it comes to creating high-quality software systems. There are countless other “-ilities” out there, each with its own unique benefits and applications. As a software engineer, it’s important to stay up-to-date on the latest trends and best practices in order to create software that meets the needs of users and stakeholders.
So, if you have a favorite “ility” that we haven’t mentioned, or if there are others that you consider essential to software engineering success, please comment below and let us know!
Let’s talk About Your Data and/or Digital Transformation