Reliability, Scalability, and Maintainability are some of the least understood concepts of application development. Even with little understanding of these topics, many developers use them on a day-to-day basis during their work conversations. A proper and sound understanding of these concepts enables you to make proper use of these terminologies and think effectively to enforce these vital concepts in applications you build.
As online applications get more sophisticated, efficient scalability, dependability, and maintainability, become increasingly important to ensure smooth performance and user pleasure. Effectively handling these parts of web app development can be difficult, especially for developers who are new to the profession or are unfamiliar with these concepts.
In this series of blog posts, we will be understanding these terminologies inside and out. We will explore ways of thinking about reliability, scalability, and maintainability in the applications we build.
Who loves un-reliability?
Would you, as a user, ever prefer to use an application that crashes frequently, does not work as intended, and perform terribly?
A typical user would have the following expectations from a reliable application –
- The application should perform the function as expected by the user.
- It can tolerate user’s mistakes
- It provides good enough performance
- Prevent security and safety
Taking all these things together, we can informally define reliability as – “Continue to work properly, even when things go wrong“.
Faults – The things going wrong
Any component of an application that deviates from its normal functioning is called a Fault. Applications that anticipate faults and can handle them are called Fault-tolerant applications.
The goal of a reliable application is to minimize the chances of faults occurring. While it is impossible to completely prevent any kind of fault, the application should have measures in place to ensure that a fault does not lead to a catastrophic system failure. This includes providing redundancy, introducing fault tolerance and providing recovery mechanisms in the event of a fault. With the right measures in place, a reliable application can help ensure that the system continues to run smoothly even in the face of faults.
Let us take a look at different kinds of faults that can occur in any application.
Hardware Faults
Hardware faults are the easiest to think of. These can be the result of hard disk crashing, RAM becoming faulty, power outages, or network issues.
One of the simplest ways to prevent hardware faults is to add redundancy to the system. So we may have multiple power supplies, multiple disks with redundant data, and hot-swappable CPUs. When one component faults, the redundant component can take its place.
Software Faults
While hardware faults are random, there is another class of faults that are more systematic. These faults result from something wrong with the software. Following are some of the things that can lead to software faults –
- Bug in software that causes it to crash whenever a certain input is received
- A process taking shared resources like RAM or CPU causing other processes to starve
- A critical service becoming unresponsive or very slow
There is no simple solution for addressing software faults. Because of wide-ranging issues leading to software faults, preventing them also takes several different kinds of measures.
It is often a good practice to review the assumptions made while building the system. For example, an e-commerce application might be built on the assumption that users will order only if the item is in stock. But this assumption might be incorrect in the context of the application, paving way for software faults.
Thorough testing is another way of catching software faults before they appear in deployments. Measuring, monitoring, and analyzing running applications are also ways of catching software faults.
Faults due to Human Errors
Humans create and maintain all of the apps. Numerous human decisions and behaviors are the direct sources of application system flaws. Regardless of the extent of automation, we cannot remove humans from the equation. So, how can we make our systems dependable in the face of untrustworthy humans? There are several approaches that we generally take to eliminate human-related faults.
- Design systems that reduce opportunities for errors.
- Test thoroughly at all levels.
- Allow quick and easy recovery from human errors.
- Set up detailed monitoring.
Why should applications be reliable?
Building reliable applications is the responsibility of every developer. There are situations where we are forced to sacrifice the reliability of applications for things like operational costs or development costs. But these sacrifices should be made with extreme conscious.
With this, we come to the end of this first blog on the reliability of applications. We saw why reliability is a crucial aspect of application development and what kinds of faults we should avoid while creating applications. In the upcoming posts, we will explore the other two aspects of application development. Till then, keep learning and keep growing!
Enjoy what you are reading? Consider following me on Twitter!
By: Rishabh Agarwal
Originally published at Hackernoon
Source: Cyberpogo
