Implementing SOLID Principles in Dart: Building Robust and Maintainable Code | Part 1

Why should I learn SOLID Principles?

You might be aware of several advantages of Dart, where one of the prominent one being shipping feature rich application on multiple platforms using a single code base using Flutter framework. That sounds incredibly cool as it saves effort for Designers & Product Team, and also reduces overall cost for development.

But sometimes we (DEVs) take a little bit of added liberty and write code without a structure to ship features even faster. That comes with its own sets of advantages and disadvantages. Lets talk about them…

Let us have a look at the advantages first-

1. The obvious advantage being able to ship multiple features on or before time ⚡.
2. If simplicity and quick development are the primary goals, then not strictly adhering to the SOLID principles will allow faster initial implementation.
3. When code is intended for temporary use or as a proof of concept, bypassing SOLID principles can save time and effort.
4. In the early stages of a project when requirements are evolving rapidly, adhering strictly to SOLID principles may slow down the development process. Hence, relaxing these principles temporarily can provide more flexibility to accommodate frequent changes and iterations. Needless to say that the developers should remain the same throughout the process.

Hmm… So, there are some advantages of not adhering to SOLID principles. But they will not look so appealing once we discuss the disadvantages in a moment. But, before we start with disadvantages, let’s ask some questions to ourselves-

1. Have you ever worked on a codebase written by another developer(s) and found yourself living a nightmare?
2. Have you ever found a class where everything; starting from making network calls, to handling input events and updating UI; happens in the same class?
3. Have you ever found functions which are trying to do multiple things at the same time?
4. Have you tried to change one thing to solve the bug at hand resulting in creation of several other bugs?
5. Have you ever experienced difficulty in implementing a new feature in the existing system without major changes?
6. Do you feel the need to improve upon your existing caliber and are missing structure in the code you write?
7. Have you stumbled upon a codebase where the code looks so organized that it becomes too difficult to understand? 😂

If the answer to any of the above questions is YES, then learning SOLID Principles is a very good start to improve upon your own skills of visualization, structuring, organization, abstraction, modularity, etc. and also write code that can be maintained and improved easily by several other developers.

If you were unable to relate with the questions asked above, then don’t fret, here’s a list of traditional disadvantages-

1. Fragility: Lack of adherence to SOLID principles can result in fragile code that is prone to breaking when modifications are made. A small change in one part of the codebase can inadvertently impact other unrelated components, leading to unexpected failures and difficult debugging processes.
2. Rigidity: Code that violates SOLID principles generally tends to be tightly coupled and difficult to modify. Making changes in one part of the codebase often requires modifications in multiple places, leading to a rigid system that is resistant to change. This increases the risk of introducing bugs and makes future enhancements or updates more challenging.
3. Low reusability: Code that does not follow SOLID principles tends to have low reusability. Components are often tightly coupled, making it difficult to extract and reuse specific functionalities in different contexts. This reduces code modularity and increases duplication, resulting in increased development effort and decreased productivity.
4. Poor testability: Violating SOLID principles can make code difficult to test effectively. Dependencies between components are not well-defined, and isolation of units for testing becomes complex. Without proper test coverage, it becomes harder to ensure the correctness and reliability of the code, leading to potential bugs and regressions.
5. Lack of scalability: Code that lacks adherence to SOLID principles may struggle to scale effectively. As the codebase grows, it becomes increasingly difficult to maintain and extend the system. Without clear separation of concerns and well-defined interfaces, introducing new features or adapting the codebase to changing requirements can be time-consuming and error-prone.
6. Increased technical debt: Neglecting SOLID principles can lead to the accumulation of technical debt over time. Technical debt refers to the additional effort required in the future to fix, refactor, or improve code that was implemented hastily or without proper design considerations. Technical debt can slow down development speed, hinder innovation, and increase the likelihood of project delays and failures.

Conclusion-

After considering the above arguments, it is clear that in the long run following SOLID Principles will lead to a much more robust, maintainable & testable codebase and not adhering will gradually lead to an increasing Technical Debt, neglecting which will gradually make the code very difficult to work upon. In the upcoming articles, we’ll discuss SOLID principles in detail.