Clean Code Basics: Stop Copy-Pasting and Start Using Functions (DRY)

Let's explore one of the clean code basic principle, named DRY: Don't repeat yourself, is it matters? Is it not? That's what we'll find out today!

Welcome back, brave coder 👨‍💻, into this series of clean codes basics. My question for you today is the following: have you ever found yourself copy-pasting code snippets, while thinking 💭: "I’ll clean this up later" ?

Let’s be honest 😅, often, "later" never comes 😂, and repeated code blocks remain scattered throughout the project. This is where the DRY (Don’t Repeat Yourself) principle can save time, reduce errors, and simplify refactoring. In this article, we’ll dive into DRY principles and how they make your code more efficient, readable, and maintainable.

Ala Barakati Lah, lets goo!

---

❌The Cost of Copy-Pasting Code

While copy-pasting seems like a quick fix haha, it can quickly transform to a big mess:

• Error-Prone: When you need to fix a bug in one instance, you may forget to update the copies. Inconsistent fixes lead to confusing behavior and frustrating debugging sessions.

• Difficult to Maintain: The more repeated code, the harder it becomes to update or improve it across your application.

• Code Bloat: Repeated blocks clutter up files, making it harder to read and navigate your codebase.

Repeated code can lead to inconsistent behavior if one instance is updated, but others are not. Imagine a team project where the same error message logic is pasted in five different files haha, keeping them consistent becomes a nightmare 😬. But if you follow the DRY principle, one central function handles it all, so you only have to make the change in one place.

---

✅Embracing Functions for Reusability

Functions are a great way to make your code DRY. They encapsulate specific actions so that the logic is defined once and reused as needed. Any future changes only need to happen in one place, saving both time and potential headaches. (simple, easy and straight forward)

Example: Creating Reusable Utility Modules

For more complex projects, DRY principles can be applied with utility modules that centralize common functionality. For example, many applications need validation checks like email formats, password strength, or age verification. Instead of writing these checks separately in each file, bundle them in a single validation module.

❌Before:

// email validation
const emailRegexPattern = /\S+@\S+\.\S+/
if (emailRegexPattern.test(email)) console.log("Valid email");

// password validation
if (password.length >= 8 && password.length <= 16) console.log("Strong password");

// this code will be repeated when ever you need to make these kind of validations for email & password!!

✅After:

// Defined once and used anywhere
// validation.js
const validateEmail = (email) => /\S+@\S+\.\S+/.test(email);
const validatePassword = (password) => password.length >= 8 && password.length <= 16;

module.exports = { validateEmail, validatePassword };


// Import them anywhere in your project
const { validateEmail, validatePassword } = require('./validation');

if (validateEmail("test@example.com")) console.log("Valid email");
if (validatePassword("strongPass123")) console.log("Strong password");

---

💡When to Be Careful with DRY

While the DRY principle is generally a good rule of thumb, there are a few cases where it should be applied carefully:

• Premature DRYing: Avoid abstracting code too early. Sometimes, different pieces of code appear similar but serve different purposes! DRYing too soon can lead to complex abstractions that actually increase code complexity!

• Over-using Shared Modules: When everything is cycled in shared functions, modules can become overly dependent on each other, making the code harder to test and understand.

The key is to find a balance, remember DRY should make code cleaner, not complex.

🏁Conclusion

The DRY principle is a powerful tool in the toolkit of clean coding. It encourages you to create reusable code, reducing duplication and making your project more maintainable and less error-prone. By following DRY principles, you’ll be saving yourself, and your teammates, plenty of headaches 😂.

PS: Next time you’re tempted to copy and paste code, think about how you can turn it into a reusable function or module. In the end, DRY code isn’t just cleaner; it’s smarter. It’s your pathway to writing efficient, readable, and scalable code.

That’s it for today’s article, see you soon!

🔔 Don't forget to subscribe to my blog and YouTube channel to stay updated with all the latest content!