You're struggling to write modular code. What are some ways to improve your ability?

The DRY (Don't Repeat Yourself) principle emphasizes code reuse to enhance modularity. By adhering to DRY, developers avoid duplicating code by abstracting common functionalities into reusable modules or functions. Modular code promotes separation of concerns, making it easier to maintain, debug, and extend. When a change is needed, developers update the code in one place, ensuring consistency throughout the application. This practice reduces the risk of introducing bugs and improves code readability. Moreover, modular code encourages a modular mindset, fostering the creation of independent and interchangeable components that can be combined to build complex systems efficiently while promoting scalability and maintainability.

"Don't Repeat Yourself" is a fundamental software development principle aimed at reducing redundancy and promoting code reusability, maintainability, and consistency. In simple terms, it's about not repeating your code. For instance, if your code contains multiple modules executing an identical functionality, you can encapsulate this within a function (or equivalent) and then invoke this function whenever needed, instead of duplicating the same logic repeatedly. This approach certainly contributes to developing a modular code.

The DRY principle goes hand in hand with refactoring, this is because when you see something that has already been implemented but needs a little tweak to your new needs then you can refactor that code to meet your needs. Some functions that seems to be related can be reused better if they are refactored into their own module.

Coding standards will lead you to a path of better coding patterns. Use linters/formatters to enforce coding standards, some of the standards will make you think of modular code such as function code length or number of arguments.

Vertical Slice Architecture or VSA allows us modularize applications into different vertical slices. It lets us produce highly coherent code by segregating related business functionalities together. Each slice is independent of another, thus less coupling. CQRS, Mediator and asynchronous messaging helps us decouple each module from another and ensure separation of concerns by segregating crosscutting concerns like authorization, validation, logging, caching etc from the core business logic. Last but not the least, the patterns discussed above increase maintainability and testability.

Refactoring is often overlooked due to rapid feature deployment, but is one of the key components in modular code. When features are added, some code may really be too integrated, but taking a second look and looking for refactoring opportunities will open up ideas on how to make code more modularized

Examples for following the DRY principle in .NET are as follows. Logging Module: Instead of scattering console.log statements, create a single logging function that formats and tags logs. This method, reused across projects, ensures consistent logging and simplifies updates. Email Validation: Rather than duplicating a regex pattern for email validation in different forms, use a centralized isValidEmail function. This approach avoids inconsistencies and eases maintenance if validation rules change.