How Is Deep Learning Different From Regular Programming?

# Regular programming: rules written by you
def discount(age, is_member):
    if is_member and age >= 60:
        return 0.20   # 20% off
    elif is_member:
        return 0.10   # 10% off
    elif age >= 60:
        return 0.05   # 5% off
    else:
        return 0.0

# Same input always gives the same output
print(discount(65, True))   # 0.20
print(discount(65, True))   # 0.20
print(discount(30, False))  # 0.0

Characteristics of regular programming:
- Explicit rules written by the programmer
- Deterministic output for the same input
- Easy to unit test
- Easy to trace and debug
- No training data required
- Works well when rules are known
- Fast and cheap to run
- Does not improve with more data
- Fails when rules are unclear or too complex

# Deep learning: the model learns the rules
# (simplified pseudocode)
model = NeuralNetwork()

for epoch in range(50):
    for images, labels in training_data:
        predictions = model(images)
        loss = cross_entropy(predictions, labels)
        loss.backward()
        optimizer.step()

# Prediction returns probabilities, not exact rules
probs = model(new_image)
# e.g. [0.93 "cat", 0.07 "dog"]

# Correctness is measured statistically
print(accuracy(model, validation_set))  # 0.94

Characteristics of deep learning:
- Rules are learned, not written
- Outputs are probabilistic
- Needs lots of labelled data
- Needs compute (GPU) and time
- Tested with metrics, not assertions
- Debugged by inspecting data and loss
- Improves with more and better data
- Excellent for perception and language tasks
- Harder to interpret, harder to explain

What changes when you move to deep learning:
- You stop writing logic and start curating data
- You cannot "fix" a bug by editing one line
- You look at loss curves instead of stack traces
- You accept that 94% is often "good enough"
- You add confidence thresholds to your app
- You monitor models after deployment
- You retrain when data drifts
- You document data, not just code

New habits to build:
□ Start every project by inspecting the data
□ Track experiments, not just commits
□ Use validation sets religiously
□ Measure accuracy, precision, recall
□ Log predictions and confidence scores
□ Build fallbacks for low-confidence cases
□ Document data sources and versions
□ Monitor model performance in production
□ Plan for retraining and drift

Project Comparison:
Problem: _________

Regular programming approach:
- Rules to write: _________
- Inputs: _________
- Outputs: _________
- Complexity: _________

Deep learning approach:
- Data needed: _________
- Model type: _________
- Training cost: _________
- Accuracy target: _________

Chosen approach: _________
Why: _________

Decision Checklist:
□ Are the rules clear and stable?
□ Can rules be written by a human in reasonable time?
□ Do we have labelled data?
□ Do we have compute budget?
□ Does the task involve perception (images, audio, text)?
□ Do we need explainability?
□ Is a 90-95% accuracy acceptable?
□ Can we monitor and retrain the model?

If mostly yes → regular programming
If mostly no and we have data → deep learning

Hybrid Plan:
Problem: _________

Use deep learning for:
1.
2.
3.

Use regular programming for:
1.
2.
3.

How they connect:
- Model returns prediction
- App applies rules and guardrails
- Low-confidence cases fall back to rules
- Logs feed future retraining

Success criteria:
- Model accuracy target: _____%
- Rule coverage: _____%
- Fallback rate: _____%