Keys To Building High Quality Software
If you’ve been reading our articles, you’ll often notice we emphasize that we build high-quality software.
So what exactly do we mean by that? In this article, we will aim to address the different tenets of high quality software from our perspective.
Due to the evolving nature of software, high quality may mean different things to different people. This is highlighted by the fact that after decades of boom, software quality is still extremely hard to measure.
Software is ever-evolving.
Software is never done.
This makes it really hard to provide standards to measure software quality.
A Mobile App may have a completely different set of parameters that make it high quality when compared to a Web Application.
The principles we address here apply to majority of software development. These principles are ubiquitous and are time-tested.
A lot of great articles touch many of these concepts we have identified below. We will try to provide an exhaustive list of links to take you down the rabbit hole.
Note: This post will be updated with references as we find good ones. You may want to bookmark this page!
UI/UX
Yes. A great User Experience is the most fundamental aspect of high quality software. It is so important that we identify it as a top MUST-HAVE when building Software.
Many may ask, “Wait, what does this have to do with Software Development?”
The truth is that your Software touches thousands of lives on a daily basis. If you’re privileged, it will affect millions of people.
Software touches thousands of lives on a daily basis. If you’re privileged, it will affect millions of people. Take time and effort to craft it well.
UI/UX is our language of love when dealing with our customers. We want to empower our customers by giving them the best possible means of interacting with our software. We want to provide the best experience from the time they log in to our software to the time they close it out. We want to provide consistency in user experience, confidence in actions and easy access to data when interacting our software.
Consistency — We provide this by making sure that we maintain a consistent flow of screens across the software so users learn quickly.
Confidence — We ensure that we always give users feedback on their actions so that they know exactly what’s going on when they interact with our system.
Access to Information — We also ensure that the user can get to all related data within 2–3 clicks from any given part of the application. This is to support our 360-degree data philosophy that allows users to master their domain and feel confident when using our software.
We make it mandatory for our Software developers to understand the art of UI/UX through blogs like Smashing Magazine. We also help build high quality software by building user interface flows using tools like Balsamiq and Sketch.
These tools eliminate any unknowns and allow stakeholders as well as developers truly understand the importance of building systems with a great user experience. This isn’t nearly enough. There’s more…
We dabble with building User personas, success metrics, on-boarding and user-experience flows as well as SWOT analysis for many of our products to clearly identify the scenarios to give a user the best experience when using our software.
SOLID Principles
SOLID principles offer a fool-proof way of building high quality software. This 5-letter acronym is a must-needed approach towards building high quality software.
Majority of our software construction practices involve building software using the SOLID principles. You can read more about SOLID here and here.
We always ensure that our developers are following these principles when building software. Whether it is through regular trainings, code-reviews or Mob driven development methodologies, we ensure that our developers never lose sight of SOLID.
DDD
DDD stands for Domain Driven Design. It allows software developers to build software in collaboration with business experts in a language that is understood by them.
A domain is a realm in which the software application is being developed. The application interacts with other sub-components and sub-systems in a very specific manner under this realm.
It is important to capture the activities, the interactions and the vocabulary of this realm so that we can truly build a system that resonates with the stakeholders.
DDD allows us to capture the complexity of the software by understanding the various contexts in which systems operate. We also represent this domain using a ubiquitous language making it easier to understand the interactions between systems.
DDD simplifies software development, greatly improves flexibility and ensures that more importance is given to the domain (and domain experts). You can read more about DDD here and here.
We have also built reusable libraries of the most common domains in E-Commerce, Event Ticketing, Social Networking etc. to greatly simplify software development.
Agile Development Model
We have previously written about our Software Development processes here and here.
We truly believe that Agile helps you “build the right things” and high quality software principles help you “build it right”. A great product is a healthy mix of building the right thing and building it right using strong software principles.
Using tools like JIRA, Trello, Asana or Microsoft Planner will truly allow you to build great product backlogs and understand your priorities and in-turn help build high quality software.
Source Control
To this very day, we are often amazed when we find source code that isn’t hosted in a good source control system like Git, Mercurial or Team Foundation Server (TFS).
A great software development agency will always use a distributed source control solution similar to Git or Mercurial.
All software development should take into account source control best practices when building new feature sets or release management. This article provides complete guidelines into Gitflow.
Great teams are able to deliver high quality software not just because of strong development practices, but also because of the ability to manage source control using the best practices.
Event Logging
If you’re not logging events and activities that are occurring within your software as they occur, you’re missing out.
Logging allows you to truly understand the system usage in the real-world. Patterns previously unidentified will start evolving. Bugs that you couldn’t re-produce will suddenly come to light. Metrics related to performance will be measured more effectively. The list goes on and on…
All of the apps we’ve built in the last 4–5 years have involved detailed logging to allow our teams to help us build better software. It has reduced our troubleshooting time, helped us fix bugs faster and also helped in eliminating performance bottlenecks. It has also squashed many of our assumptions about system usage and helped address developers that product poorly written code.
Self-Healing/Reactive Systems
Organizations are working in disparate domains and expect their software to span multiple domains as well. They expect their software to be flexible, resilient, robust and scalable.
They expect that the systems to scale under high traffic scenarios and scale down when no longer needed. They expect optimal use of resources. Organizations also expect their systems to be fault-tolerant by having in-built redundancy patterns that may span geographies to help them operate under disaster scenarios.
We address these needs by building software that is truly resilient, elastic, responsive and loosely-coupled so that it can adapt to the changing needs of our customers.
Configuration
We build our software to run based on configuration parameters so that we can easily swap them out between development, production and test environments.
We prevent developers from unauthorized access to production environment variables using these configuration parameters. We also release many features using configuration switches. This allows us to test certain features on a specific set of customers before we roll them out to others.
Continuous Integration/Deployment
We have recently experienced the joys of CI/CD in our development practices. Using tools such as Microsoft Team Services, CircleCI or Jenkins have allowed use to streamline our build processes to run test scripts after building code to ensure that we are still OK to go live. We can rollback a queued release or rollback to a prior release easily using such tools.
Security
Security is software is often an after-thought for majority of the software developers. This needs to change. With security risks growing by the day, security must be taught and utilized in all software development processes. Where do you start? Let’s start with the OWASP Top 10 Vulnerabilities, the Microsoft Security Guidelines, GDPR Compliance and Microsoft’s GDPR Compliance guidelines. Developers may also review secure coding practices based on the framework of their choice.
Test Driven Development
TDD means different things to different people.
At a bare minimum, TDD can be considered as a pragmatic way of Software development where tests are written to test various functional elements defined by User Stories and Use cases.
Building software using tests increases confidence and helps identify bugs quickly during the development process. You can read more about TDD here.
We believe in writing comprehensive unit tests. We’ll be the first to admit that every time we have decided not to write unit tests for a given piece of software (due to budgetary requirements imposed by our customers), we have regretted doing so.
We have integrated TDD not as a separate phase i.e. QA phase as many would call it, but a part of our on-going development process thus making it a part of our software development budget.
These are some of our principles for building high quality software. Do you have any? Feel free to post your comments and we will update our post accordingly.
Additional Reading:
- 12-Factor App — https://12factor.net/
- The Reactive Manifesto — https://www.reactivemanifesto.org/
Like What You Read?
Hire Us! We are a dynamic team with over 40 years of collective Software experience under our belt. We have delivered software spanning multiple verticals. Learn more about us at https://www.hypertrends.com
