Copy-Paste Programming Anti-Pattern — Duplicated Code

In this tutorial, you'll learn how Copy-Paste Programming creates maintenance problems through duplicated code.

What You'll Learn

how Copy-Paste Programming creates maintenance problems through duplicated code.

Why It Matters

Bugs in duplicated code must be fixed N times. Each copy increases maintenance cost linearly.

Real-World Use

Similar code blocks across multiple files, repeated SQL queries, and duplicated validation logic.

The Copy-Paste Programming Pattern

The Copy-Paste Programming pattern addresses a specific recurring design problem by providing a reusable solution structure. Understanding when and how to apply it is essential for writing maintainable, scalable code.

Key Concepts

• Recognition: Identifying the anti-pattern in existing code.
• Root Cause: Understanding what led to the anti-pattern.
• Refactoring Path: Step-by-step migration to a better design.
• Prevention: Establishing practices that prevent recurrence.

Structure

The following diagram shows the structure of this pattern:

flowchart TD
    subgraph Bad["CopyPasteProgramming: Anti-Pattern"]
        A[God Class] --> B[Does everything]
        B --> C[Hard to test]
        C --> D[Brittle]
    end
    subgraph Good["Fixed: SRP"]
        F[Component A] --> G[Component B]
    end

Implementation

# Anti-pattern: Bad example
class UserManager:
    def __init__(self):
        self.users = []
        self.db = None
        self.cache = None
        self.logger = None
        self.email = None
        self.validator = None
        # ... 20 more dependencies

    def process(self, user_data):
        # 200-line method doing everything
        self.validate(user_data)
        self.save_to_db(user_data)
        self.send_email(user_data)
        self.update_cache(user_data)
        self.notify_admin(user_data)
        self.log_action(user_data)
        self.cleanup(user_data)
        self.refresh_dashboard(user_data)
        # Single responsibility violation

Expected output:

```python
# Fixed with Single Responsibility Principle
class UserValidator:
    def validate(self, data): ...

class UserRepository:
    def save(self, data): ...

class EmailService:
    def send_notification(self, user): ...

class UserProcessor:
    def __init__(self, validator, repo, email):
        self._validator = validator
        self._repo = repo
        self._email = email

    def process(self, user_data):
        self._validator.validate(user_data)
        user = self._repo.save(user_data)
        self._email.send_notification(user)
        return user

## Key Participants

- **Client**: Code that uses the Copy-Paste Programming.
- **Copy-Paste Programming**: The main abstraction provided by the pattern.
- **Implementation**: Concrete realization of the pattern.
- **Data/State**: Information managed by the pattern.

## Real-World Examples

- DodaTech uses this pattern internally for consistent cross-cutting concerns.
- Major frameworks and libraries implement this pattern as a core architectural element.
- Production systems at scale depend on this pattern for reliability.

## Related Patterns

- Lava Flow

- Dead Code

- Spaghetti Code

- Design Patterns — the complete patterns catalog.

## Pros and Cons

| Pros | Cons |
|------|------|
| Identifying anti-patterns prevents poor design decisions | Can be difficult to recognize in your own code |
| Refactoring improves code quality and maintainability | Refactoring may require significant effort |

## Common Mistakes

1. ****Over-engineering**: Applying Copy-Paste Programming where a simpler solution suffices, adding unnecessary complexity.

2. ****Wrong granularity**: Implementing Copy-Paste Programming at the wrong level of abstraction.

3. ****Thread Safety ignored**: Using Copy-Paste Programming in concurrent context without proper synchronization.

4. ****Tight coupling**: Violating the pattern intent by creating hidden dependencies.

5. ****Premature optimization**: Introducing Copy-Paste Programming before there is evidence it is needed.

## Practice Questions

1. What problem does the Copy-Paste Programming pattern solve? Describe a real-world scenario where using it improves code quality.

2. How does Copy-Paste Programming differ from alternative approaches? What are the trade-offs?

3. What testing <a href="/design-patterns/strategy/">Strategy</a> would you use for code that implements Copy-Paste Programming?

4. How would you refactor legacy code to introduce Copy-Paste Programming?

5. When should you NOT use Copy-Paste Programming? Describe scenarios where it adds unnecessary complexity.

### Challenge

Implement a complete Copy-Paste Programming example in Python with unit tests. Include error handling, edge cases (empty data, null values, concurrent access), and a performance comparison against a simpler alternative. Document your design decisions.

### Real-World Task

Find a section of code in your current project that could benefit from the Copy-Paste Programming pattern. Refactor it, write tests, and measure the improvement in testability, coupling, and cohesion.

> **Security Tip:** When implementing Copy-Paste Programming, ensure proper input validation, avoid exposing internal state, and follow Least Privilege. At DodaTech, all implementations undergo security review.


---

*Built by the developers of Doda Browser, DodaZIP, and Durga Antivirus Pro.*