What are your approaches to writing modular and well-structured code, utilizing design patterns, and implementing effective documentation and testing practices to ensure code longevity and ease of maintenance?
Follow the DEVteam for more discussions and online camaraderie!
Top comments (8)
Ooh, my favourite question!
The formula that worked best for me is keeping things that belong together close to each other. Each separate feature gets its own folder and has all related components inside: repositories, controllers, utilities, templates etc.
The only rule is to never import anything from siblings: if something needs to be reused it should be moved to the top.
This way, whenever I make changes I always know the exact scope of what those changes might affect. Helps tremendously with debugging!
And lastly, keeping things simple makes everything so much more pleasant to work with! So I avoid fancy abstractions unless they are truly necessary and prefer simple functions to classes.
Well written.
It would be great if you post any image of this architecture.
Good point, I think I can make a whole article out of it! Will post here once it’s out too 👌
Sure waiting for it.
Here it comes, hope you'll find it useful:
dev.to/valeriavg/plug-play-modular...
I'd start by saying each of the following are "means to an end", and not "ends to a mean".
The actual "end" is building value thru code quicker/more-efficiently for end users. Doing so requires you to be able to do things "fast" and more reliably, which in turns leads to investments in coding patterns, re-using code, documenting, testing and the like.
However, when taken in the context that documentation/testing/modular code is just a "means to an end" you actually need to consider that documentation/testing/modular code is actually somewhat "in the way" of progress. If your code works perfectly, you don't need tests. If its self documenting then you don't need docs. If you aren't re-using anything, then it doesn't need to be reusable. If its already simple, then you don't need it to be modular.
Of course getting to such a state might be plainly impossible in all facets, but keeping the context in mind can help reduce the investment in these realms as they are just "means to an end".
Finally, reducing how much time/effort put into these aspects could help get you to the real "end". Utilizing tools/patterns/approaches that integrate these aspects with as minimal amount of work should always be the goal.
The most reusable code is the one that simplifies one complex operation required in multiple places, striking a balance between abstraction and specificity.
Maintainable code is easy to understand and to change: functions, arguments and variables are aptly named. Only if the reasoning behind the functionality is not obvious, it should be added as comment. The code is automatically tested, so that changes cannot break the functionality undiscovered.
Reusability of the code is a myth spreading already 20+ years and supported by OOP languages. The only OOP that is normal - is in JS, which by the way is constantly attacked by ECMA.