Files

T

Antigravity Agent f8b21af4be Wiki cleanup: error-doc removal, dedup merge, link normalization

10_Wiki/Topics 대규모 정리:
- 오류 캡처/미완성 stub 문서 227개 제거
- 교차폴더 중복 43클러스터 병합 (63파일 → redirect)
- 링크명 정규화: 깨진 링크 수정·redirect 직결·개념 매핑 ~2,400건
- 카테고리 MOC 6개 신규 생성
- Graph 섹션 미해결 related-keyword 링크 10,058건 제거

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

2026-05-20 23:52:15 +09:00

6.0 KiB

Raw Blame History

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

title

Feedback Loops in Systems

매 한 줄

"매 output 의 portion 의 input 으로 routed back — 매 system 의 self-regulation / self-amplification 의 fundamental mechanism". Wiener 의 cybernetics (1948) → Forrester 의 system dynamics (1961) → Meadows 의 Thinking in Systems (2008) → 매 SRE / RL / market-design 까지 매 universal.

매 핵심

매 두 polarity

Reinforcing (R, +): 매 same-direction amplification → 매 exponential growth or collapse. 매 viral growth, bank runs, flywheel.
Balancing (B, −): 매 opposite-direction correction → 매 goal-seeking equilibrium. 매 thermostat, autoscaler, supply-demand.
매 system 의 behavior = sum of all loops, with delays.

매 4 building blocks (Meadows)

Stocks (state, accumulator).
Flows (rate of change).
Information links (signals).
Delays (transport, perception, action).

매 typical archetypes

Limits to growth: R + B (resource constraint).
Shifting the burden: short-term fix B undermines long-term solution.
Tragedy of the commons: many R + 1 B.
Success to the successful: 2 R coupled.
Drift to low performance: B with eroding goals.
Escalation: 2 R + delay (arms race).

매 stability

매 negative loop 의 gain > 1 + delay → 매 oscillation, overshoot.
매 positive loop 의 unchecked → 매 runaway / collapse.
매 Bode / Nyquist 의 control-theory 의 quantitative tool.

💻 패턴

Thermostat (B loop, ODE)

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

setpoint, k_loss, k_heat = 22.0, 0.1, 0.5
def dT(T, t):
    heat = k_heat if T < setpoint else 0
    return -k_loss*(T-10) + heat
t = np.linspace(0, 100, 1000)
T = odeint(dT, 15, t)
plt.plot(t, T); plt.axhline(setpoint, ls="--")

PID controller (B with derivative damping)

class PID:
    def __init__(self, kp, ki, kd, dt):
        self.kp,self.ki,self.kd,self.dt = kp,ki,kd,dt
        self.i, self.prev = 0, 0
    def __call__(self, sp, pv):
        e = sp - pv
        self.i += e*self.dt
        d = (e - self.prev)/self.dt
        self.prev = e
        return self.kp*e + self.ki*self.i + self.kd*d

Reinforcing loop — viral growth

def viral(t_max=30, k=0.2, init=10, cap=1e6):
    n=[init]
    for _ in range(t_max):
        n.append(min(cap, n[-1]*(1+k)))   # R loop
    return n
# 매 limits-to-growth 의 cap 의 추가 — pure exponential 의 unrealistic.

Logistic — R + B (limits to growth)

def logistic(K=1e6, r=0.3, t_max=60, init=10):
    x=[init]
    for _ in range(t_max):
        x.append(x[-1] + r*x[-1]*(1-x[-1]/K))
    return x

Stock-and-flow (Forrester) with simpy

import simpy, random
env = simpy.Environment()
inventory = simpy.Container(env, init=100, capacity=1000)
def supplier(env):
    while True:
        yield env.timeout(2)
        if inventory.level < 50:               # B loop on stock
            yield inventory.put(60)
def customer(env):
    while True:
        yield env.timeout(random.expovariate(1))
        yield inventory.get(1)
env.process(supplier(env)); [env.process(customer(env)) for _ in range(5)]
env.run(until=100)

Autoscaler (SRE B loop)

def autoscaler(metric, target=0.6, replicas=3, max_r=20):
    err = metric - target
    delta = round(err * replicas / target)
    return max(1, min(max_r, replicas + delta))

Causal-loop diagram (text DSL)

Users ─R→ Content ─R→ Engagement ─R→ Users      (viral R)
Users ─B→ Server-load ─B→ Latency ─B→ Users     (capacity B)
delay: server provisioning ≈ 10 min  → oscillation risk.

매 결정 기준

상황	Approach
Continuous physical / control	PID / state-space
Discrete event business / supply chain	System Dynamics (stocks-flows)
Service capacity	B loop autoscaler + SLO error budget
Growth product strategy	Map R loops; identify limit B; remove constraint
Policy / market	Causal-loop diagram + agent-based sim
Stability analysis	Linearize → Bode / root-locus

기본값: 매 design 의 첫 단계 = CLD (Causal Loop Diagram) + delay 표시 + leverage point 식별.

🔗 Graph

부모: Systems_Thinking · Cybernetics Foundations · Control-Theory
변형: Reinforcing-Loop · Balancing-Loop
응용: Feedback-Control-Systems · Reinforcement-Learning

🤖 LLM 활용

언제: 매 unintended consequence 의 prediction, 매 product growth 의 root-cause, 매 SRE incident 의 cascading 분석, 매 policy design 의 leverage point. 언제 X: 매 fully open-loop 의 simple pipeline (매 unnecessary modeling).

❌ 안티패턴

Loops without delay: 매 real systems 의 always have delays — 매 oscillation 의 missed.
Linear thinking in nonlinear loop: 매 small input change 의 huge output (or vice versa).
Optimizing one node: 매 ignoring loop → 매 Goodhart, perverse incentives.
Goal erosion: 매 missed-target → 매 lower target → 매 drift.
Fixing symptom (B): 매 underlying R loop 의 unaddressed (shifting the burden).

🧪 검증 / 중복

Verified (Wiener 1948; Forrester 1961; Senge 1990; Meadows 2008; Designing Data-Intensive Apps on backpressure).
신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1 placeholder
2026-05-10	Manual cleanup — archetypes + 7 patterns + decision matrix

6.0 KiB Raw Blame History Unescape Escape