서론, 복잡성이 왜 문제인가
Fred Brooks는 1986년 ”No Silver Bullet“에서 소프트웨어를 어렵게 만드는 특징으로 복잡성(Complexity), 적합성(Conformity), 변경 용이성(Changeability), 비가시성(Invisibility) 네 가지를 꼽았다. 그런데 2006년 Ben Moseley와 Peter Marks는 논문 ”Out of the Tar Pit“에서 이 네 가지 중 진짜 근본 원인은 복잡성 하나뿐이라고 주장한다. 적합성은 기존 시스템의 복잡한 제약에 맞춰야 하는 문제이고, 비가시성은 복잡한 구조를 눈에 보이는 형태로 그려낼 수 없다는 문제이며, 변경 용이성이 어려운 이유도 결국 시스템이 복잡해서 어디를 건드려야 할지 알 수 없기 때문이다. 네 가지는 서로 다른 특성을 가지고 있지만 결국 하나, 복잡성으로 수렴한다.
복잡성 하나로 수렴시키는 이유는 복잡성이 소프트웨어의 신뢰성, 납기, 보안, 성능, 비용 문제 대부분의 공통 원인으로 지목되기 때문이다. 어떤 문제든 해결하려면 먼저 시스템을 이해해야 하는데, 그 이해를 가로막는 것이 다름 아닌 복잡성이다. Dijkstra와 Corbató가 거듭 단순함을 강조한 것도 같은 이유였고, Hoare는 1980년 튜링상 연설에서 “돈으로 살 수 없는 단 하나의 품질이 있다면 신뢰성이다. 신뢰성의 대가는 철저한 단순함을 추구하는 것”이라고 말했다.
그런데 이러한 단순함은 어렵다. “Out of the Tar Pit”은 단순함이 어려운 이유를 이렇게 든다. 문제를 이해하고, 불필요한 요구사항을 제거하고, 복잡성을 분리하고, 상태와 제어 흐름과 의존성을 최소화하고, 적절한 추상화를 찾고, 이 설계를 지속적으로 반복해야 하기 때 문이다. 복잡성은 추가만 하면 되기에 쉽지만, 단순함은 계속 생각하고 설계해야 해서 어렵다. 하지만 복잡성이 어디서 생기는지 원인을 추적할 수 있다면 그중 상당수는 피할 수 있다고 이 논문은 낙관한다.
이 글의 1부는 복잡성이 실제로 어디서 생겨나는지, 그중 어디까지가 피할 수 없는 부분인지 이론으로 분석한다. 2부는 이 분석 내용을 진단 질문으로 바꿔 지금 코드에 어떤 복잡성이 있는지 확인하는 도구로 만든다. 3부는 진단에서 걸리는 문제마다 구체적인 처방을 하나씩 놓고 해결 방안을 제시한다. 4부는 이 모든 처방이 손대지 못하는 영역, 즉 업무 자체에 내재한 복잡성 앞에서 무엇을 해야 하는지로 마무리한다.
글 전체의 예제는 정기결제 지갑 서비스 하나로 통일한다. 사용자는 지갑에 코인을 충전해서 쓰거나 송금할 수 있다. 은행 계좌를 등록해 두면 거기서 지갑으로 충전할 수 있는데, 계좌 등록은 필수가 아니다. 계좌를 등록하려면 외부 API로 본인확인을 거쳐야 하고, 계좌번호가 실재하는지도 외부 API로 확인해야 한다. 이메일이 블랙리스트에 있으면 등록할 수 없고, 이메일은 전체 사용자 사이에서 유일해야 한다. 처음 등록하는 사용자에게는 500코인을 지급한다. 1부와 2부에서는 이 서비스의 코드 조각으로 문제를 보이고, 3부에서는 같은 요구사항을 처방마다 다시 설계한다.
제1부 복잡성 분석
복잡성의 4가지 원인
”Out of the Tar Pit“은 대규모 시스템에 남아 있는 복잡성의 원인을 상태(State), 제어(Control), 코드량(Code Volume) 세 가지로 좁히고, 여기에 언어의 과도한 자유도라는 네 번째 요인을 덧붙인다.
상태가 만드는 복잡성
고객센터에 전화를 걸었을 때 “다시 시도해보세요”, “새로고침 해보세요”, “프로그램을 재시작하세요”, 심하면 “운영체제를 재설치하고 프로그램을 다시 까세요”라는 답을 들어본 적이 있다면, 상태(state)가 만드는 복잡성을 몸으로 체험한 것이다. 이런 답변이 통하는 이유는 실제로 효과가 있기 때문이다. 효과가 있는 이유는 많은 시스템이 상태를 다루는 데서 오류를 내기 때문이다. 그리고 오류가 나는 이유는 상태가 존재하는 것만으로 프로그램이 이해하기 어려워지기 때문이다.
문제의 크기는 숫자로도 드러난다. 상태를 저장하는 비트 하나를 추가할 때마다 프로그램이 가질 수 있는 전체 상태의 수는 두 배로 늘어난다. 상태가 몇 개만 쌓여도 사람이 머릿속으로 시뮬레이션할 수 있는 범위를 순식간에 넘어선다.
더 나쁜 것은 오염(contamination)이다. 상태를 갖지 않는 함수라도 내부에서 상태를 가진 다른 함수를 호출하는 순간, 그 함수 역시 상태의 맥락 안에서만 이해할 수 있게 된다.
테스트도 마찬가지로 취약해진다. 어떤 입력에 대한 테스트 결과는 다른 입력에 대해 아무것도 말해주지 않는다는 것이 테스트의 근본적 한계인데, 상태가 있으면 같은 입력이라도 시스템이 어떤 상태에 있었는지에 따라 결과가 달라진다. 입력의 조합만으로도 감당하기 벅찬데, 여기에 상태의 조합까지 곱해진다.
다음 코드는 정기결제 지갑의 충전 로직을 상태를 직접 변경하는 방식으로 짰다.
Before
class Wallet {
private long balance;
private int retryCount;
private boolean locked;
void charge(long amount) {
if (locked) {
retryCount++;
if (retryCount > 3) {
throw new IllegalStateException("잠금 해제 필요");
}
return;
}
balance += amount;
retryCount = 0;
}
}이 코드가 옳은지 확인하려면 charge를 한 번 호출한 결과만으로는 부족하다. 호출 시점에 locked가 어떤 값이었는지, retryCount가 몇이었는지에 따라 같은 amount를 넣어도 결과가 달라진다. balance, retryCount, locked 세 필드는 서로 다른 시점에 서로 다른 이유로 바뀌므로, 이 객체가 가질 수 있는 상태의 조합은 세 필드 각각의 가능한 값을 모두 곱한 만큼 존재한다. 필드 하나를 더 추가하면 그 필드가 가질 수 있는 값의 수만큼 조합이 다시 곱해진다.
제어가 만드는 복잡성
제어(control)는 일이 벌어지는 순서에 관한 개념이다. 문제는 프로그래머가 순서에 관심이 없는 경우에도 대부분의 명령형 언어가 순서를 명시하도록 강제한다는 점이다.
a = b + 3;
c = d + 2;
e = f * 4;이 세 줄은 서로 값을 주고받지 않는다. 어떤 순서로 실행되든 결과는 같다. 그런데도 언어의 의미론상 이 코드는 위에서 아래로 순서대로 실행된다고 규정되어 있다. 이 코드를 읽는 사람은 실제로는 무의미한 이 순서를 일단 유효한 제약으로 가정하고 읽기 시작해서, 다시 살펴본 뒤에야 순서가 무관하다는 것을 확인해야 한다. 짧은 예제에서는 이 확인이 순식간에 끝나지만, 코드가 복잡해질수록 순서가 정말 무의미한지 판단하는 일 자체가 만만치 않은 작업이 된다. 판단을 잘못하면 발견하기 어려운 버그로 이어진다. 프로그래머가 요청하지도 않은 순서를 언어가 강제로 부여하고, 그 부여된 순서가 실제로는 무관하다는 것을 다시 확인하는 이중의 낭비가 발생한다.
이 순서 의존성은 추상적인 예제에서 그치지 않고 실제 버그로 이어진다. 정기결제 지갑의 충전 우대 할인율이 “회원 할인 5%, 생일 할인 10%, 이벤트 할인 15% 중 조건을 만족하는 가장 높은 값을 적용한다”는 규칙을 따른다고 하자. 이 규칙 자체에는 순서가 없다. 조건을 만족하는 후보를 모아 그중 최댓값을 고르면 그만이다. 그런데 다음처럼 짜면 순서가 몰래 끼어든다.
Before
int discountRate = 0;
if (member.isMember()) discountRate = 5;
if (member.isBirthday()) discountRate = 10;
if (event.isActive()) discountRate = 15;이 코드는 할인율이 낮은 조건부터 높은 조건 순으로 우연히 나열되어 있어서 지금까지는 결과가 맞았다. 이후 “골드 회원 할인 20%“가 추가되면서, 기존 코드에 익숙한 개발자가 관례대로 마지막 줄에 조건을 덧붙인다.
if (member.isGoldMember()) discountRate = 20;
if (event.isActive()) discountRate = 15; // 이벤트 조건이 골드 회원 할인을 덮어쓴다골드 회원이면서 이벤트 기간과 겹치면 20%가 아니라 15%가 적용된다. 원인은 할인 규칙이 아니라 대입문이 실행되는 순서다. 이 규칙에는 애초에 순서가 없으므로, 후보를 모아 최댓값을 고르는 방식으로 바꾸면 순서 자체가 코드에서 사라진다.
After
int discountRate = Stream.of(
member.isMember() ? 5 : 0,
member.isBirthday() ? 10 : 0,
event.isActive() ? 15 : 0,
member.isGoldMember() ? 20 : 0
)
.max(Integer::compareTo)
.orElse(0);이제 어느 위치에 추가하든 결과는 달라지지 않는다. 문제는 if문이 있다는 사실이 아니라, 순서가 없는 규칙에 실행 순서라는 불필요한 제약을 얹었다는 점이다. 이렇게 문제 자체에는 없던 제약이 프로그램을 짜는 방식 때문에 생기는 복잡성은 뒤의 절에서 우연적 복잡성이라는 이름으로 정의한다.
동시성이 더해지면 문제는 한 단계 더 나빠진다. 상태가 있는 두 스레드가 뒤섞이면 똑같은 초기 상태와 똑같은 입력으로 테스트를 두 번 실행해도 같은 결과가 나온다는 보장이 사라진다. 입력이 같아도 상태에 따라 결과가 달라지는 문제에, 이번에는 실행 순서에 따라서도 결과가 달라지는 문제가 겹친다.
코드량이 만드는 복잡성
코드량 자체는 부차적인 원인이다. 상태와 제어를 다루는 코드가 결국 코드량으로 쌓이기 때문에 따로 떼어 말할 필요가 없어 보이지만, 두 가지 이유로 독립적으로 짚을 가치가 있다. 측정하기 가장 쉬운 지표라 는 점, 그리고 다른 원인들과 나쁜 방향으로 상호작용한다는 점이다. 코드가 많아질수록 같은 상태를 읽고 쓰는 자리가 늘고 순서를 지켜야 하는 호출도 늘어서, 이해에 드는 노력이 코드 길이보다 가파르게 커진다. Brooks는 이 비선형 증가를 본질적 복잡성의 증거로 들었다. Dijkstra는 다르게 봤다. 지적 노력이 프로그램 길이의 제곱에 비례한다는 법칙이 증명된 적은 없으며, 추상화를 제대로 쓰면 이해에 드는 노력은 길이에 비례하는 정도로 그칠 수 있다고 반박했다. 상태와 제어를 잘 관리한 시스템에서는 코드량이 늘어나도 복잡성이 비선형으로 폭증하지 않는다. 코드량의 비선형 증가는 코드 자체의 숙명이 아니라, 상태와 제어를 방치했을 때 나타나는 결과에 가깝다.
언어의 자유도가 만드는 복잡성
네 번째 원인은 언어가 허용하는 자유도다. C의 자유로운 메모리 관리가 대표적이다.
Wallet *w = malloc(sizeof(Wallet));
// ... 사용
free(w); // 호출을 잊으면 누수, 두 번 호출하면 오류해제 시점과 여부를 프로그래머가 직접 판단해야 하고, 판단을 틀려도 그 대가는 한참 뒤 프로그램이 실행되는 도중에야 드러난다. 언어가 막아 주지 않는 한 이런 실수는 코드가 커질수록 어딘가에서 일어나기 마련이다. 가비지 컬렉션이 복잡성을 줄인 이유는 새로운 규칙을 추가해서가 아니라 수동 메모리 관리라는 자유도 자체를 없앴기 때문이다. 같은 원리가 상태에도 적용된다. 상태를 쓰지 말라고 아무리 권고해도 언어가 상태 자체를 허용하는 한 문제는 남는다. 3부에서 다룰 불변 record와 순수 함수는 이 자유도를 언어 수준에서 좁히는 처방이다. 상태를 바꿀 수 없게 만들면 상태를 잘못 다룰 자유도 함께 사라진다.
네 가지 원인은 서로 독립적으로 작동하지 않는다. 상태와 제어가 결합하면 상태에 따라 분기하는 프로그램이라는, 둘을 따로 다룰 때보다 훨씬 이해하기 어려운 결과물이 나온다. 원인을 알아보기 어려울 정도로 시스템이 복잡해지면 이미 있는 기능인지 확인하는 일조차 버거워져서 같은 기능이 중복으로 만들어진다. 마감이 임박했다면 이 경향은 더 심해진다. 복잡성은 새로운 복잡성을 부르는 방향으로 저절로 굴러간다. 이 악순환을 끊으려면 의식적인 개입이 필요하고, 그 개입의 첫 단계는 어떤 복잡성을 없앨 수 있고 어떤 복잡성은 없앨 수 없는지 가르는 일이다.
또 다른 구분, 본질적 복잡성(Essential Complexity)과 우연적 복잡성(Accidental Complexity)
Brooks는 “No Silver Bullet”에서 소프트웨어의 어려움을 본질(Essential)에서 오는 것과 우연(Accidental)에서 오는 것으로 나누고, 소프트웨어의 복잡성은 우연이 아니라 본질적인 속성이라고 결론 내렸다. 지금 남아 있는 복잡성 대부분은 피할 수 없다는 뜻이다. “Out of the Tar Pit”에서는 복잡성 자체가 소프트웨어의 필연적 속성이 아니며, 단순하면서도 여전히 소프트웨어인 프로그램을 얼마든지 만들 수 있고, 지금 시스템에 있는 복잡성의 상당 부분은 본질적이지 않다고 본다. “Out of the Tar Pit”에서 세운 기준은 이렇다. 본질적 복잡성 은 사용자가 보는 문제 자체에 내재한 복잡성이고, 우연적 복잡성 은 그 나머지 전부다. 개발팀이 이상적인 세계에서는 다룰 필요가 없었을 복잡성, 이를테면 성능 문제나 언어와 인프라의 한계에서 오는 복잡성이 여기 속한다.
이 기준을 요구사항과 구현으로 나누면 더 정확해진다. 사용자가 원하는 것, 즉 기능 요구사항(무엇을 할 수 있어야 하는가)과 비기능 요구사항(얼마나 빨라야 하는가, 얼마나 안정적이어야 하는가, 데이터가 얼마나 안전해야 하는가)은 사용자의 문제에 속하므로 본질적이다. 반면 그 요구사항을 만족시키려고 개발팀이 고르는 기술적 메커니즘, 이를테면 어떤 자료구조를 쓸지, 노드끼리 어떤 프로토콜로 조율할지, 어떤 캐싱 전략을 쓸지는 우연적이다. 이 둘을 가르는 실용적인 시험은 대안의 존재 여부다. 같은 요구사항을 만족시키는 구현 방법이 여럿 있다면, 그 방법을 선택하며 생기는 복잡성은 문제 자체가 아니라 풀이가 만든 것이므로 우연적이다. 이 정의는 “본질적”이라는 말을 일상어보다 훨씬 엄격하게 쓴다. 사용자가 그 존재조차 모르는 것이라면 정의상 본질적일 수 없으므로, 스레드풀이나 반복문의 카운터 변수는 물론 비트와 바이트, 컴퓨터 자체도 본질적인 것이 아니다.
이 기준을 가상의 실험으로 확인해보자. 이상적인 세계에서는 성능을 걱정할 필요가 없고, 언어와 인프라가 필요한 모든 것을 지원한다고 하자. 이 세계에서 개발팀이 할 일은 사용자의 비공식 요구사항을 형식 요구사항으로 바꾸고, 그 형식 요구사항을 범용 인프라 위에서 그대로 실행하는 것뿐이다. 이 경로에 필요 없는 상태, 필요 없는 순서 제어가 있다면 그것은 정의상 우연적이다. 정기결제 지갑에서 사용자에게 지금까지 적립된 총 포인트를 보여주는 기능이 있다고 하자. 충전 내역을 순회해서 매번 합산하지 않고 별도의 totalEarnedPoints 필드에 저장해두고 충전할 때마다 갱신하는 방식을 택했다면, 이 필드는 파생 데이터를 상태로 만든 것이므로 우연적 복잡성에 해당한다. 충전 내역만 있으면 총 적립 포인트는 언제든 다시 계산할 수 있어서, 원칙적으로는 상태로 들고 있을 필요가 없기 때문이다.
이 파생 상태가 치르는 대가는 저장 공간이 아니라 동기화 책임이다. 충전 내역에 행을 추가하는 것과 totalEarnedPoints를 갱신하는 것은 서로 다른 두 번의 쓰기이므로, 한쪽만 반영하고 다른 쪽을 빠뜨리는 코드가 섞여 들어오면 충전 내역과 합계가 어긋난다. 두 요청이 동시에 들어오면 문제는 더 커진다. 두 스레드가 같은 totalEarnedPoints 값을 읽고 각자 자기 몫을 더해 저장하면, 나중에 쓴 값이 앞선 갱신을 덮어써서 한쪽 적립분이 사라진다. 이렇게 파생 가능한 값을 상태로 별도로 들고 있는 순간 갱신 누락, 동시 갱신 충돌, 원본과 파생값의 불일치를 계속 확인해야 하는 책임이 함께 생긴다. 캐시나 집계 값을 두는 선택 자체가 잘못은 아니지만, 그 선택은 성능과 동기화 책임을 맞바꾸는 거래라는 사실은 남는다.
이 구분은 “복잡한 게 원래 그런 것”이라는 체념을 반박할 근거를 준다. 복잡성 전부가 문제 자체에서 나온 것이라면 손댈 방법이 없지만, 상당수가 도구와 구현 방식의 산물이라면 그 부분은 없앨 수 있는 대상이 된다. 본질적 복잡성에 대해서는 사용자와 함께 다루는 수밖에 없지만, 우연적 복잡성은 개발팀의 선택으로 줄일 수 있는 영역이다.
최근에는 우연적 복잡성을 줄이는 도구도 늘었다. LLM 기반 코딩 도구는 라이브러리 마이그레이션이나 보일러플레이트 작성처럼 사용자의 문제와 무관한 반복 작업을 대신 처리하고, TLA+ 같은 정형 검증 도구는 상태 전이 규칙을 사람이 눈으로 좇는 대신 기계로 증명하게 한다. 다만 두 도구 모두 무엇이 본질적인지는 판단해주지 않는다. 이 절에서 세운 기준은 도구가 바뀌어도 그대로 적용된다.
가장 위험한 복잡성, Unknown Unknowns
John Ousterhout는 ”A Philosophy of Software Design“에서 복잡성을 시스템의 구조와 관련해 이해하거나 수정하기 어렵게 만드는 모든 것이라고 정의한다. 코드의 크기나 기능의 개수가 아니라 개발자가 겪는 어려움 자체로 복잡성을 규정한다. 그래서 좀처럼 손대지 않는 부분이 아무리 복잡해도 체감되는 복잡성에는 큰 영향을 주지 않고, 자주 건드리는 부분은 조금만 복잡해도 어려움이 크게 느껴진다.
Ousterhout는 이 어려움이 드러나는 방식을 변경 전파, 인지 부하, Unknown Unknowns 세 가지 증상으로 나누고, 이 증상을 낳는 원인을 의존성(dependencies)과 모호성(obscurity) 두 가지로 좁힌다. 의존성은 소프트웨어에서 완전히 없앨 수는 없지만 그 수를 줄이고 남은 것을 단순하게 만들 수는 있다. 모호성은 중요한 정보가 코드 어디에도 명시되지 않은 상태로, Ousterhout는 방대한 문서화가 필요하다는 사실 자체가 설계가 잘못됐다는 신호인 경우가 많다고 지적한다. 두 원인과 세 증상은 다음처럼 이어진다.
변경 전파는 작은 변경 하나가 여러 곳의 수정을 요구하는 문제이고, 인지 부하는 작업을 완료하는 데 알아야 할 것이 너무 많은 문제다. 이 두 증상은 코드 어디에서나 나타날 수 있다. 책임이 뒤섞인 클래스도 변경 전파를 일으키고, 관계가 얽힌 수많은 클래스도 인지 부하를 일으킨다. Unknown Unknowns는 사정이 다르다. 무엇을 해야 하는지, 제안한 해법이 실제로 동작할지조차 알 수 없는 상태를 가리키며, 원인과 결과가 사건이 벌어지기 전까지는 드러나지 않는다.
세 증상 중에서도 Unknown Unknowns가 가장 나쁘다. 두 원인 중에서는 모호성이 이 증상과 직접 맞닿아 있다. 정보가 숨어 있을수록 Unknown Unknowns는 늘어난다.
이 개념이 왜 실무에서 중요한지는 Phillip Armour가 2000년 논문 “The Five Orders of Ignorance”에서 제시한 무지(ignorance)의 다섯 단계를 보면 분명해진다. Armour는 소프트웨어를 완성된 제품이 아니라 지식을 쌓아가는 매체로 본다. 이 관점에서 무지는 다음처럼 층을 이룬다.
| 단계 | 상태 | 지갑 예시 |
| 0단계 | 알고 있고, 동작하는 시스템으로 보여줄 수 있다 (답을 가진 상태) | 충전액 100원당 1코인을 적립한다 |
| 1단계 | 모르지만 무엇을 모르는지는 특정할 수 있다 (질문을 가진 상태) | 은행 점검 시간에 계좌 확인이 실패하면 어떻게 할지 아직 정하지 않았다 |
| 2단계 | 모른다는 사실 자체를 모른다 (질문조차 세우지 못하는 상태) | 은행 점검 시간이라는 경우가 있는지조차 모른다 |
| 3단계 | 2단계를 어떻게 찾아내야 하는지 그 방법을 모른다 | 빠진 경우를 어떤 절차로 찾아야 할지 모른다 |
| 4단계 | 이 다섯 단계 모델 자체의 존재를 모른다 |
Armour는 진짜 문제가 2단계와 3단계에 있다고 본다. 2단계는 견적이 크게 빗나가는 이유, 프로젝트가 “90% 완료”에서 멈춘 채 좀처럼 끝나지 않는 증상, Brooks가 말한 2차 시스템 효과(첫 시스템의 성공 뒤에 만드는 두 번째 시스템에 아껴 뒀던 기능을 전부 밀어 넣어 비대해지는 경향)를 설명한다. 표의 지갑 예시처럼, 계좌 등록이 실패할 수 있는 경우의 수를 설계 시점에 다 헤아렸다고 믿었지만 운영에 들어간 뒤 은행 점검 시간, 한도 초과, 명의 불일치 같은 경우가 새로 튀어나오는 상황이 2단계 무지다. 설계 시점에는 그런 경우가 있는지조차 몰랐으므로 질문으로 세울 수도 없었다.
3단계에 대한 Armour의 통찰이 이 개념 전체에서 가장 힘이 센 대목이다. 설계 리뷰든 테스트 주도 개발이든, 4부에서 다룰 EventStorming이든, 소프트웨어 개발 방법론은 모두 3단계를 다루는 절차다. 그런데 이 절차가 하는 일은 답을 내놓는 것이 아니라 2단계에 머물러 있던 무지를 1단계의 질문으로 끌어올리는 것뿐이다. EventStorming 자리에서 업무 담당자가 “은행 점검 시간에는 어떻게 하죠”라고 묻는 순간 그 경우는 2단계에서 1단계로 올라온다. 답은 아직 없지만 질문은 생겼다. 방법론을 도입하면서 “이걸 따르면 놓치는 게 없어지나요”라고 묻는다면 그 자체가 오해다. 방법론이 실제로 돌려주는 것은 답이 아니라 질문이며, 그 질문에 답하는 일은 방법론이 아니라 여전히 사람의 몫으로 남는다.
이 통찰은 Ousterhout가 짚은 모호성과 정확히 맞물린다. 모호성을 줄인다는 것은 결국 코드에 숨어 있던 2단계의 무지를 1단계의 질문으로 끌어올리는 작업이다. 3부에서 다룰 Deep Module과 정보 은닉이 이 모호성을 줄이는 구체적인 기법이고, 층으로 격리하는 처방 역시 층 사이의 의존을 정리해 의존성을 줄이는 접근이라는 점에서 이 절의 문제의식과 직접 이어진다. Ousterhout는 이 두 기법이 지향하는 목표를 명확한 시스템(obvious system)이라는 한마디로 정리한다. 깊이 생각하지 않고 낸 빠른 추측이 대체로 맞아떨어지는 시스템을 가리킨다.
Simple 대 Easy, Rich Hickey의 통찰
Rich Hickey는 2011년 강연 “Simple Made Easy”에서 두 단어를 정확히 구분하는 데서 논의를 시작한다. Simple의 어원은 라틴어 “sim”(하나)과 “plex”(접힘, 꼬임)이 합쳐진 말로, 하나로 꼬여 있지 않은 상태를 가리킨다. 무언가가 얽혀 있는지 아닌지는 관찰할 수 있는 사실이므로 Simple은 객관적 속성이다. 반면 Easy의 어원은 “가까이 있다”는 뜻의 라틴어에서 왔다. 물리적으로 가까이 있어서 설치하자마자 쓸 수 있다는 뜻일 수도 있고, 이미 익숙한 것과 비슷하다는 뜻일 수도 있고, 자신의 실력 범위 안에 있다는 뜻일 수도 있다. 세 의미 모두 누구에게 가까운가에 좌우된다. 그래서 Easy는 상대적 속성이다. 나에게 쉬운 것이 다른 사람에게는 어려울 수 있다.
Hickey는 이 구분 위에 complect(뒤얽다)라는 개념을 세운다. 복잡성은 원래 분리되어야 할 것들을 뒤얽는 데서 생긴다. 하나를 이해하려면 거기 얽혀 있는 모든 것을 함께 머릿속에 담아야 하므로, 이 부담은 조합론적으로 늘어난다. 상태(state)가 결코 단순할 수 없는 이유도 같다. 상태는 값(value)과 시간(time)을 뒤얽는다. 같은 메서드를 같은 인자로 호출해도 호출 시점에 따라 결과가 달라진다면, 그 복잡성은 캡슐화의 경계를 뚫고 바깥으로 새어 나온다. 앞서 본 Wallet의 charge가 겪은 문제, 즉 같은 amount를 넣어도 호출 시점의 retryCount와 locked 값에 따라 결과가 달라지던 현상이 이 뒤얽힘의 구체적인 사례다.
Hickey는 이런 식으로 뒤얽히기 쉬운 선택들과, 그 대신 택할 수 있는 단순한 선택들을 짝지어 제시한다.
| 뒤얽히기 쉬운 선택 | 대안 |
| 객체(state, identity, value가 함께 묶임) | 값(value) |
| 메서드(함수와 상태가 결합) | 함수 |
| 상속(타입들을 뒤얽음) | 조합 가능한 다형성(상속 계층 없이 인터페이스나 프로토콜로 행동을 조합) |
| switch·패턴 매칭(여러 결정이 한 곳에 닫힘) | 조합 가능한 다형성 |
| 반복문(무엇을 할지와 어떻게 할지가 뒤얽힘) | 집합 연산(map, filter, reduce처럼 순회 방식을 감춘 컬렉션 연산) |
| ORM(데이터와 표현이 뒤얽힘) | 선언적 데이터 조작(SQL처럼 무엇을 원하는지만 적는 질의) |
| 조건문 분기(규칙이 코드 곳곳에 흩어짐) |

