Mistake #7: The Copy-Paste Trap 관련

Why Your Code is Slow: Common Performance Mistakes Beginners Make

---

Maybe you’ve experienced something like this before: you’ve written code that works, but when you hit “run,” it takes forever. You stare at the spinner, wondering if it’s faster to just solve the problem by hand. But you end up looking something like...

• Problem 1: The Ghost Copies in “Harmless” Operations
• Problem 2: The Hidden Cost of “Functional” Code
• Problem 3: The “I’ll Just Modify a Copy” Mistake
• How to Escape the Copy-Paste hell?

---

Why Your Code is Slow: Common Performance Mistakes Beginners Make

Maybe you’ve experienced something like this before: you’ve written code that works, but when you hit “run,” it takes forever. You stare at the spinner, wondering if it’s faster to just solve the problem by hand. But you end up looking something like...

You’d never download 10 copies of the same movie. But in code? You’re probably cloning data all the time without realizing it. Here’s how invisible copies turn your app into a bloated, slow mess—and how to fix it.

---

Problem 1: The Ghost Copies in “Harmless” Operations

What you think happens

“I sliced a list—it’s just a reference, right?”

What actually happens

In many languages, slicing creates a full copy of the data. Do this with large datasets, and you’re silently doubling memory usage and CPU work.

Python Example

# A 1GB list of data  
big_data = [ ... ]  # 1,000,000 elements  

# Accidentally cloning the entire list  
snippet = big_data[:1000]  # Creates a copy (harmless, right?)  

# Better: Use a view (if possible)  
import numpy as np  
big_array = np.array(big_data)  
snippet = big_array[:1000]  # A view, not a copy (0MB added)

Why this hurts

• Copying 1GB → 2GB of RAM used.
• If this happens in a loop, your program could crash with MemoryError.

The Fix:

• Use memory views (numpy, memoryview in Python) or lazy slicing (Pandas .iloc).
• In JavaScript, slice() copies arrays—replace with TypedArray.subarray for buffers.

---

Problem 2: The Hidden Cost of “Functional” Code

What you think happens

“I’ll chain array methods for clean, readable code!”

What actually happens:

Every map, filter, or slice creates a new array. Chain three operations? You’ve cloned your data three times.

JavaScript Example:

// A 10,000-element array  
const data = [ ... ];  

// Slow: Creates 3 copies (original → filtered → mapped → sliced)  
const result = data  
  .filter(x => x.active)  
  .map(x => x.value * 2)  
  .slice(0, 100);  

// Faster: Do it in one pass  
const result = [];  
for (let i = 0; i < data.length; i++) {  
  if (data[i].active) {  
    result.push(data[i].value * 2);  
    if (result.length === 100) break;  
  }  
}

Why this hurts:

• 10,000 elements → 30,000 operations + 3x memory.
• Functional programming is elegant but can be expensive.

The Fix:

• Use generators (Python yield, JS function*) for lazy processing.
• Replace method chains with single-pass loops in hot paths.

---

Problem 3: The “I’ll Just Modify a Copy” Mistake

What you think happens

“I need to tweak this object. I’ll duplicate it to avoid side effects.”

What actually happens

Deep cloning complex objects (especially in loops) is like photocopying a dictionary every time you edit a word.

Python Example:

import copy  

config = {"theme": "dark", "settings": { ... }}  # Nested data  

# Slow: Deep-copying before every edit  
for user in users:  
    user_config = copy.deepcopy(config)  # Copies entire nested structure  
    user_config["theme"] = user.preference  
    # ...  

# Faster: Reuse the base config, overlay changes  
for user in users:  
    user_config = {"theme": user.preference, **config}  # Shallow merge  
    # ...

Why this hurts:

• deepcopy is 10-100x slower than shallow copies.
• Multiplied by 1,000 users, you’re wasting minutes.

The Fix:

• Use immutable patterns: Create new objects by merging instead of cloning.
• For big data, use structural sharing (libraries like immutables in Python).

---

How to Escape the Copy-Paste hell?

1. Ask: “Do I need a copy?”: 90% of the time, you don’t. Use views, generators, or in-place edits.
2. Profile memory usage: Tools like memory_profiler (Python) or Chrome DevTools (JS) show copy overhead.
3. Learn your language’s quirks:
   • Python: Slicing lists copies, slicing NumPy arrays doesn’t.
   • JavaScript: [...array] clones, array.subarray (TypedArray) doesn’t.