What is a scalable code?

Question

Scalability is linked to growth, in the context of code, I have some pertinent doubts.

• What is a scalable code?
• The scalability of code involves more than one aspect or only performance or design?
• A code with low cohesion and strongly coupled would not be scalable?

Answer 1

Behold What Software Scalability Means? and then forget everything there is. Code scalability has nothing to do with application scalability. We are here (I hope) talking about how easy it is for code to grow and still be manageable. In general the scalability of code has to do with team scalability because it is rare for a code to be very large and maintained by one person, but it is possible to be only about the code.

Code scalability has nothing to do with application performance and not even directly with development productivity, although it has a link between code being manageable and productivity.

Some features of a scalable code:

• organized
• well-documented
• has little or no side effect non-local (something that affects the entire application), is orthogonal
• has good abstractions, but it is necessary to be careful with leaks that harm
• is modular (even when using OOP)
• is cohesive and unmatched
• follows the SRP (usually)
• is DRY, not being full of C and V is just a detail, but you can’t overdo it
• uses KISS and YAGNI (without exaggeration, the YAGNI can turn against you for not offering good outputs in future maintenance to put new features without affecting the whole), can not be convoluto
• has good nomenclatures
• hits the taxonomy and ontology of things
• is clean
• is elegant
• is not verbose
• doesn’t make premature optimizations
• anyway, it’s readable and easy to maintain, is an obvious code
• is not trend-oriented, everything in it serves a clear and necessary purpose.

Experiment

Scalable code can only be written by those who master all aspects of development, all the mechanisms that will be used, and those who have experience, because it is not something obvious. It is possible to do this for a less experienced team, but only under strong supervision of very experienced people, unless the team is all made up of geniuses who are born knowing, who can see the right future without having gone through something like this. One does it to work, not to be right, to be scalable, because one doesn’t even know what it is, because it will be necessary and how to make it climb.

Everyone over time, either write more scalable code, or they should leave the area. But many codes are not scalable because there is no compromise for this, either by failure of the professional, or by term demands in the short period that are imposed.

I have noticed that some software does not need to be scalable. People talk a lot about maintenance, but little is done. I work almost only with maintenance, and it seems that almost everyone works almost only with something new, will never maintain these things? Maybe the modinha won’t let you. Is it all that good? Or is it so bad that it is better to abandon?

Tools

Some languages help the code to be more scalable, for example static typing. Of course, tests can play a similar role, but not at all. Robustness helps not only in code quality, but also in code scalability. "discoverable" codes are more scalable. So dynamic typing languages are good for scripts. No problem people do scripts, many problems need them, the problem is making software Nterprise with scripts. And worse, use techniques like OOP in scripts. OOP helps you scale code if you know what you’re doing.

Certain programming patterns solve certain problems, but they can create others. The more code you write the less scalable it is, unless it simplifies something forcefully. So it’s also possible that dynamic typing language has its chance to be more scalable in some sense. Nothing that reflection and code generation does not solve in static typing languages, the second is not much used for not having many tools ready and give a little more work, but should to scale more.

Example of what may not be scalable in code: checked exceptions. This is a feature that looked good. Why only Java uses it? And almost everyone uses it badly. Because it’s not scalable. As the code grows, the hierarchy gets more complicated and the stack of call methods gets bigger and starts to have so much combination to deal with that is impractical and occurs what everyone does, treats generically. This has become so popular that the examples of Java are bad and then contaminates even other languages and everyone uses exception the wrong way because of this plague.

Answer 2

What you are talking about I call maintainability, which is the ease in maintaining / evolving code.

Scalability is usually linked to the ease in meeting an increasing demand from concurrent users (without code change), just scaling machines or containers (Docker / Kubernates).

See the definition in the link -> https://medium.com/@Yuri.live/scalability-and-Maintainability-of-mobile-and-other-Applications-part-1-21e3d07dadeb