How do you balance performance, readability, and maintainability when writing code?

[rashi24-p]

Body

Provide me answer in point, ease to understand!

Guidelines

• I have read and understood this category's guidelines before making this post.

[CopperEagle]

Hey @rashi24-p

Interesting question. Depends on the programming language to a degree.

Short answer

• Readability: How you write something, not what. Common guidelines take you there. Pick them up by looking at big repos.
• Maintainability: This is a thing you only learn over time. Using the concept of abstraction (hiding implementation behind a simple interface) is a common tool. This can be done using Classes and Inheritance. Speed up your learning by copying the big repos.
• Performance: This goes into the what. You will want to think first: What is your data? The input? The output? How do you store this in the meantime (while processing). This leads you to algorithms and datastructures. This is how you think performance at the beginning. Don't start microoptimizing until you have the very least a minimum product.

Context on Maintainability and Readability

For most programming languages there is a set of guidelines how to write readable code. Some are aesthetics, e.g. how to write documentation or use_snake_case vs camelCase. These guidelines were developed over long years of development in big software projects. You can pick them up by checking a bigger open source software repos you use regularly. For Python, check out Numpy. There are even tools rating how well your code fallows these rules. This is called linting. Pylint is a linter for Python.

Maintainability

Abstraction is key here. Let's say you have three ways to produce a car. Speedy is fast production expensive. Slow is a bit slower but cheaper. And Bruh is inefficient. All three essentially do the same thing - producing a car. The implementation is different. So you have a common interface

class BaseProductionCar:
    def produce():
        return None

You implement each of the three productions as a class, defining the produce method. From the outside, all are used the same. Calling produce. What happens behind the scenes is different.

This is a relevant example in many ways. Consider AI models. You interface often with them with a text box. But behind this text box the models are trained repeatedly or even swapped out. This, to a degree at least, insulates one change (in the implementation) from the rest of the system.

[YuheshPandian]

Steps to maintain readability, performance and maintainability in short

1. Readability

• Use a formatter like Prettier(For Web Development)
• Wise usage of Variables is necessary.
• Name your variables the most likely.
• Follow a team or project specific conventions in naming things.

2. Maintainability

• A code which is readable is well maintainable.
• Use Version Control Systems to maintain your code in the long run.
• Use containers to prevent system based issues.

3. Performance

• Making unit tests would help you to record the performance of your code I guess.
• This part is usually project based.

To balance them I would suggest you to focus on readability and maintability while writing code and work on performance part in the testing phase. I would optimize code after I have ensured that the first 2 categories are well worked on.

[ebndev]

Hey @rashi24-p, welcome to the GItHub Community!

You've got some great answers from @CopperEagle & @YuheshPandian - if they were helpful, please feel encouraged to mark one as the answer or let us know if you have other questions 😄

[LivexTwin]

Use modern Vanilla CSS features (variables, nesting) , follow easy to read naming conventions.