What makes quality software? At ESSE I we asked ourselves this question and came up with a series of answers.
We'll mention three: quality software must be functional, i.e. carry out the intended operations; it must be reliable, i.e. free of errors and malfunctions; and it must be usable, i.e. able to meet users' latent needs as well – typically, it must be simple and intuitive to use.
But the most important question we asked ourselves was "how can we achieve these goals and strike a balance between functional and non-functional aspects?"
Here too we found an answer, reaching this conclusion: to create quality software, "programming well" is not enough (in other words, technical expertise alone is not enough).
Even before that, you need to work in a quality environment.
Yes, we may sound like show-offs, but we can say we have succeeded: we have a development team of real quality that we like to describe as "in the name of harmony".
Harmony is, after all, the value we believe in most, so much so that we have set ourselves the goal of spreading it, trying to inspire other programmers like us to take this kind of approach to programming.
Of course, we don't have a magic wand that turns every team into a harmonious one (it takes much more than that to build one, but perhaps we'll talk about that in a future article). Here, though, we will try to explain our idea of quality software in the name of harmony by giving you some practical tips to help you achieve it.
That way we may also give some substance to our new payoff, "Harmony, not just bits".
Our 10 tips for creating quality software while working in the name of harmony:
- Write readable code: make sure it can be understood by whoever develops it (later on) and by other team members. Use meaningful names for variables and functions, format the code properly and add relevant comments. All things that, by reducing the risk of misunderstandings, foster harmony in the team.
- Comment your code appropriately: add comments to explain complex parts or provide additional information.
- Study and apply programming best practices: these include using design patterns, separation of concerns and adopting principles such as SOLID (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion), a methodology (to which we will certainly devote an in-depth article in future) that contributes to more effective and balanced development.
- Keep it simple: try to keep your code simple and avoid excessive complexity. Simplicity makes code easier to read, test and maintain over time. We always say: "if it's too complicated, something's wrong".
- Split your code into functions or modules to make it more modular, reusable and easy to test.
- Use meaningful names: choose variables, functions and classes that clearly describe their function and purpose. Avoid generic names or ambiguous abbreviations that could cause confusion. Foo, Bar and Baz may raise a smile but they aren't helpful; better to opt for descriptive names.
- Write automated tests: adopt test-driven development (TDD) and write automated tests to check that your code works correctly. Automated tests increase the quality and robustness of software.
- Use version control: use a version control system such as Git to keep track of code changes and make collaboration with other developers easier. This lets you go back to an earlier version of the code if necessary.
- Read and study the code of other experienced developers: it lets you learn new techniques, solutions and approaches.
- Take part in developer communities to broaden your knowledge: giving value to others and receiving it from them is also part of our way of working in the name of harmony.
We hope these tips help you improve your programming and create higher-quality software.
And if you also manage to work in a climate of harmony, you will reach the greatest goal of all: creating a feeling of pleasant harmony when your software is used by its users.
(Photo: Pexels)
