Scalability

Please note: This article is only available in English.
How would you define scalability?

Recently I was asked how I would define scalability. After a bit of thought I answered that "scalability is the ability of a system to grow without requiring parts of the system or other systems to be altered." I was then asked how a system could achieve that. That was a bummer. Is there a recipe or common strategy to get that done? My answer was "independence."

The main concept a software system needs to follow is being decoupled from potential dependencies. If a system is only loosely coupled in an environment, we can easily scale it. If we, e.g., talk to a specific server, then we cannot scale that server easily. First we would be required to exchange the server by a load balancer (physical or virtual), which would then redirect (e.g., by round-robin) the requests to other instances (physical or virtual). But that kind of scaling would at least be possible.

The scenario is much more complicated if we call local programs. It can be even worse when calling functions directly within a code. By using dependency injection and indirect calls (e.g., via interfaces) we could proxy invocations to use all registered resources. This requires a middle-layer, however, such a middle-layer does not require much attention. One possibility is to use, e.g., SignalR, for such a middle-layer. This gives us a lot of advantages, with the drawback that communication will always go over the websocket protocol, even when we could just scale within the machine. Nevertheless, usually we want to deploy on / across different machines anyway.

What is the effect of scaling components with real-time network technologies? We need to be careful about our API and the deployment process. A (easily distributable) configuration needs to be set up. The configuration has - in the best case - not to be altered when scaling individual components. Even better, components should be able to detect when it should scale up or down.

So do I still think that independence is the key for scalability? Definitely. When we create (small) services that expose their API in a real-time network system, we can connect the system as we wish. Changes can then propagate in a web that has been created dynamically.

Created .

References

Sharing is caring!