프로그래밍 이디엄

프로그래밍 이디엄(Programming Idiom)은 특정 프로그래밍 언어 또는 프로그래밍 맥락 안에서, 비교적 작은 코드 구성요소(construct)를 작성하는 관례적 방식이다. 한국어로는 보통 관용구라고 번역한다.

이디엄은 언어의 정의 자체에 포함되지는 않지만, 언어가 허용하는 표현 범위 안에서 형성된다. 이는 언어적 관용구가 단어와 문법의 규칙 안에 있으면서도 그 규칙만으로는 도출되지 않는 것과 같은 구조다.¹

이디엄에 부합하는 코드를 idiomatic이라 하고, 그에 어긋나는 코드를 idiosyncratic(특이한, 비관습적인)이라 한다. idiosyncratic 코드는 문법적으로는 맞지만 그 언어를 아는 사람에게 부자연스럽게 읽힌다.

패러다임 = 프로그램을 바라보는 사고방식
원칙     = 판단을 이끄는 추상 규칙
패턴     = 반복되는 설계 문제의 재사용 가능 해법
이디엄   = 그 언어/맥락에서 자연스러운 작은 표현 방식
문법     = 언어가 허용하는 표현 규칙

위 다섯 단계는 "사고 → 표현"의 추상도 순서다. 이디엄은 패턴보다 작은 단위에 적용되고, 문법보다 추상적이다.

핵심 정의

프로그래밍 이디엄은 다음 조건을 만족한다.

1. 특정 언어/생태계/프레임워크에 강하게 묶여 있다.
2. 비교적 작은 코드 구성요소(한 줄에서 수십 줄 수준)에 적용된다.
3. 문제 자체보다 표현 방식에 가깝다.
4. 코드 읽기와 유지보수의 기대값을 만든다.
5. 문법적으로 필수는 아니지만, 실무적으로는 사실상 표준처럼 작동한다.

규모 측면에서 이디엄은 디자인 패턴보다 작다. 둘 다 "복사-붙여넣기할 코드"가 아니라 따라야 할 템플릿이라는 점은 같지만, 디자인 패턴은 보통 여러 객체 또는 모듈의 상호작용을 다루는 반면 이디엄은 한 줄에서 수십 줄 수준의 표현 방식을 다룬다.[1] 예를 들어 싱글톤 패턴은 디자인 패턴이고, C#의 using 블록을 통한 자원 해제는 이디엄이다.

왜 중요한가

이디엄의 가치는 팀 작업에서 가장 명확하게 드러난다. 같은 언어에서 같은 일을 하는 데 여러 표현이 가능할 때, 그 중 관용적 표현을 따르면 코드를 읽는 사람의 인지 부담(cognitive load)이 감소한다.[1] 코드 읽는 시간이 줄고, 의도를 추론하지 않아도 되며, 의외의 동작 가능성을 더 빨리 배제할 수 있다.

이디엄을 모르면:

- 문법은 맞지만 어색한 코드가 나온다.
- 생태계의 표준 라이브러리와 충돌한다.
- 다른 개발자가 코드를 읽을 때 의도를 추론해야 한다.
- 언어가 제공하는 안전장치와 최적화 경로를 놓친다.
- 코드 리뷰에서 지속적으로 같은 지적을 받는다.

반대로 이디엄을 알면:

- 코드의 의도가 빨리 읽힌다.
- 언어의 기본 제약을 거스르지 않는다.
- 라이브러리와 도구가 기대하는 형태에 맞는다.
- 버그를 막는 관례를 자동으로 따른다.
- 협업 비용이 줄어든다.

크라우드소싱 환경(StackOverflow, GitHub 등)에서 자주 공유되는 코드가 사실상 이디엄의 학습 매체가 되며, 이는 개발자가 언어 장벽을 넘는 데 핵심적 역할을 한다고 알려져 있다.²

개인 메모: 그런면에서 한국인이라는 것 자체가 프로그래머로써 일종의 저주이다. 영어권 사람이 아닌것과 한국어로 사고하는 것의 차이는 크다.

이디엄과 디자인 패턴의 차이

디자인 패턴은 언어를 넘어 반복되는 설계 문제를 다룬다. 이디엄은 특정 언어의 표현 방식에 가깝다. 다만 둘은 연속적인 스펙트럼이며 "이디엄은 작은 패턴"이라고 볼 수도 있다.

디자인 패턴:
반복되는 설계 문제에 대한 추상적 해결 구조
여러 객체/모듈의 상호작용 수준
언어 독립적 (구현 형태는 언어별로 변형)

프로그래밍 이디엄:
특정 언어에서 자연스럽고 관례적인 구현 방식
한 줄에서 수십 줄 수준의 표현
언어 종속적

예를 들어 전략 패턴은 여러 언어에서 구현할 수 있지만, 구현 형태는 언어마다 달라진다.

Java:       interface + class
Python:     callable / duck typing
JavaScript: function object
C#:         interface / delegate
Rust:       trait / enum dispatch
Haskell:    함수 인자로 전달, 또는 type class

같은 패턴이라도 각 언어의 이디엄에 맞게 표현해야 한다. 패턴 책의 UML 구조를 그대로 옮기면 문법적으로는 맞아도 언어에 어색한 코드가 될 수 있다.

이디엄과 패러다임의 차이

프로그래밍 패러다임은 프로그램을 바라보는 큰 사고방식이다. 객체지향 프로그래밍, 함수형 프로그래밍, 절차적 프로그래밍 등이 여기에 속한다.

이디엄은 그보다 작다. 패러다임이 "어떤 식으로 사고할 것인가"라면, 이디엄은 "그 사고를 이 언어에서 어떻게 자연스럽게 표현할 것인가"에 가깝다.

5단 추상도로 정리하면 다음과 같다.

[큰 추상]
패러다임  : 사고방식          (객체지향, 함수형, 절차적)
원칙      : 판단 기준          (SOLID, DRY, KISS, YAGNI)
패턴      : 반복 문제의 해법    (전략, 옵저버, 팩토리)
이디엄    : 언어권의 자연 표현  (RAII, list comprehension)
문법      : 가능한 표현 규칙    (if, for, class 선언)
[작은 단위]

위에서 아래로 갈수록 언어 종속성이 커지고, 적용 단위가 작아진다.

언어별 예시

Python

Python의 이디엄은 흔히 Pythonic이라고 부른다.

# 덜 Pythonic
result = []
for i in range(len(items)):
    result.append(items[i].name)

# 더 Pythonic
result = [item.name for item in items]

대표적인 Python 이디엄:

• list / dict / set comprehension

• context manager (with)

• iterator / generator

• enumerate, zip

• EAFP (Easier to Ask Forgiveness than Permission): "허락보다 용서가 쉽다" - 예외 기반 흐름

• 대비 개념인 LBYL (Look Before You Leap): 사전 검사 기반 흐름. Python에서는 EAFP가 더 idiomatic

• duck typing

• __init__.py 기반 모듈 경계

with open("data.txt", "r", encoding="utf-8") as file:
    text = file.read()

위 코드는 파일 닫기를 직접 호출하지 않는다. with 문이 자원 해제를 보장하는 것이 Python 생태계의 표준 이디엄이다.

C++

C++의 대표 이디엄은 RAII다.

{
    std::lock_guard<std::mutex> lock(mutex);
    // critical section
}

락 획득과 해제를 객체 생명주기에 묶는다. 이 방식은 예외나 조기 반환이 발생해도 락 해제가 보장된다.

대표적인 C++ 이디엄:

C++에서 이디엄은 특히 중요하다. 언어가 강력하지만 위험한 저수준 기능을 많이 제공하기 때문에, 관용구가 사실상 안전장치 역할을 한다.

상세한 C++ 이디엄은 이 곳을 참조

개인 메모: 개인적으로 C++의 가장 큰 문제는 버전이 너무 많고, 파편화 되있다. C++로 된 프로그램 쓰는 건 좋으나 내가 작업해야할 현장에서 C++를 보고 싶진 않다. 

JavaScript / TypeScript

JavaScript와 TypeScript에서는 비동기 처리와 객체 조합 방식이 중요한 이디엄이다.

// 덜 idiomatic
fetch(url)
  .then((response) => response.json())
  .then((data) => {
    console.log(data);
  });

// 현대 TypeScript에서 더 자주 쓰는 형태
const response = await fetch(url);
const data = await response.json();
console.log(data);

대표적인 JS/TS 이디엄:

• async / await

• object destructuring, spread/rest

• immutable update

• discriminated union

• type guard

• optional chaining (?.)

• nullish coalescing (??)

• module boundary 중심 설계

TypeScript에서는 단순히 타입을 붙이는 것보다, 타입이 런타임 구조를 설명하게 만드는 방식이 중요하다.

type Result<T> =
  | { ok: true; value: T }
  | { ok: false; error: string };

function handle(result: Result<number>) {
  if (result.ok) {
    return result.value;
  }

  throw new Error(result.error);
}

이런 discriminated union은 TypeScript에서 오류 경로를 명시적으로 표현하는 대표적 이디엄이다.

C#

C#에서는 LINQ, using, async/await, property, dependency injection 등이 강한 이디엄으로 작동한다.

using var stream = File.OpenRead(path);

IDisposable 자원의 수명을 using에 맡기는 것은 C#다운 방식이다.

대표적인 C# 이디엄:

• using / IDisposable

• LINQ

• property

• async/await + Task<T>

• extension method

• nullable reference type (string?)

• dependency injection

• record type

• pattern matching (switch expression)

Go

Go의 이디엄은 명시성과 단순성을 강하게 강조한다.

result, err := doSomething()
if err != nil {
    return fmt.Errorf("doing something: %w", err)
}

대표적인 Go 이디엄:

• 명시적 에러 반환 + err != nil 검사

• fmt.Errorf + %w로 에러 wrapping

• goroutine + channel 기반 동시성

• defer로 자원 해제 예약

• 묵시적 인터페이스 구현 (Java/C#의 명시적 선언과 대비)

• 작은 인터페이스 선호 (io.Reader, io.Writer)

• 패키지 이름과 동일한 단순한 import path

type Reader interface {
    Read(p []byte) (n int, err error)
}

인터페이스를 작게 유지하고 구현체가 묵시적으로 만족시키는 방식이 Go의 표현 철학이다.

Rust

Rust의 이디엄은 소유권 모델과 명시적 오류 처리를 중심으로 형성된다.

fn read_config(path: &Path) -> Result<Config, ConfigError> {
    let contents = fs::read_to_string(path)?;
    let config: Config = toml::from_str(&contents)?;
    Ok(config)
}

대표적인 Rust 이디엄:

• Result<T, E> + ? 연산자

• Option<T> + pattern matching

• 소유권 이전 (move) vs 빌림 (&, &mut)

• trait 기반 추상화

• match 와 exhaustiveness 검사

• builder 패턴 (StructBuilder::new().with_x().build())

• newtype wrapper로 의미 분리

• 무분별한 .clone() 회피

match value {
    Some(x) if x > 0 => println!("positive: {}", x),
    Some(_) => println!("non-positive"),
    None => println!("missing"),
}

pattern matching이 단순한 분기가 아니라 데이터 구조에 대한 직접 질의로 사용된다는 것이 Rust의 표현 감각이다.

Haskell

Haskell의 이디엄은 함수 합성과 타입 시스템의 활용에 집중된다.

processItems :: [RawData] -> [Result]
processItems = map transform . filter isValid

대표적인 Haskell 이디엄:

• 함수 합성 (.)과 point-free 스타일

• do-notation으로 monadic computation 표현

• type class 기반 ad-hoc polymorphism

• Maybe / Either로 부재와 실패 표현

• pattern matching + guards

• 게으른 평가를 활용한 무한 자료구조

• Functor / Applicative / Monad 추상 활용

readConfig :: FilePath -> IO (Either String Config)
readConfig path = do
    contents <- readFile path
    return (parseConfig contents)

Haskell에서 이디엄은 종종 수학적 추상(monad, functor)에 직결되며, 다른 언어로 번역할 때 가장 손실이 큰 영역이기도 하다.

Anti-idiom: 명시적으로 피해야 할 표현

이디엄을 가르치는 데 양보다 음의 예시가 더 효과적인 경우가 많다. 각 언어 생태계에는 "이렇게 쓰지 말라"고 명시적으로 여겨지는 anti-idiom의 카탈로그가 존재한다.

Python:
- mutable default argument: def f(x=[]):
- bare except 절: except:  (예외 종류 명시 없이)
- 전역 변수 변경 (global 키워드)
- type hint 없는 공개 API

C++:
- 헤더에 using namespace std;
- raw new / delete (스마트 포인터 대신)
- C 스타일 캐스트 ((int)x)
- 가상 소멸자 없는 다형성 클래스

JavaScript / TypeScript:
- == (느슨한 비교, === 사용)
- var (let / const 사용)
- any로 타입 시스템 우회 (TypeScript)
- 직접 mutation으로 React 상태 변경

C#:
- async void (이벤트 핸들러 제외)
- .Result / .Wait() 동기 차단
- 빈 catch 블록
- IDisposable을 using 없이 사용

Go:
- 에러 무시 (_ = err)
- nil 채널/슬라이스에 대한 가정
- goroutine 누수 (context 없이 무한 대기)
- panic을 일반 에러 흐름에 사용

Rust:
- 무분별한 .clone()으로 borrow checker 우회
- unwrap() 남용 (Result/Option 직접 처리)
- unsafe 블록 남용
- 큰 enum variant를 Box 없이 사용

Anti-idiom은 단순한 스타일 문제가 아니다. 대부분 안전 또는 성능에 실제 영향을 주며, 린터와 정적 분석 도구가 적극적으로 탐지하는 대상이다.

이디엄의 시대성

이디엄은 고정 상수가 아니다. 언어 표준의 개정, 표준 라이브러리의 진화, 커뮤니티 합의의 이동에 따라 세대가 바뀐다. 따라서 이디엄을 논할 때는 "어느 시대의 이디엄"이라는 시간 좌표가 함께 필요하다.

C++의 세대 변화

C++98 시대:
- std::auto_ptr
- raw new / delete
- 직접 작성한 컨테이너 순회

C++11 이후:
- std::unique_ptr / std::shared_ptr
- range-based for
- auto, lambda, move semantics

C++17 / C++20 이후:
- std::optional, std::variant
- structured bindings
- 컨셉(concepts), 모듈, 코루틴

C++98 코드를 그대로 두면 작동은 하지만, 현대 C++ 관점에서는 idiomatic하지 않다.

Python의 세대 변화

Python 2:
- print 문, unicode 명시 (u"...")
- xrange / range 구분
- new-style class 대 old-style class

Python 3:
- print 함수, 문자열 = unicode 기본
- f-string (3.6+)
- type hint (3.5+, 3.10+에서 |로 union)
- dataclass, asyncio
- 구조 분해와 match-case (3.10+)

JavaScript의 세대 변화

ES5 시대:
- var, function 선언
- prototype 기반 상속
- callback hell

ES6 이후:
- let / const, arrow function
- class 키워드, 모듈 import/export
- Promise, async/await
- destructuring, spread/rest
- optional chaining, nullish coalescing (ES2020)

같은 언어에서도 코드를 작성하거나 평가할 때 "이건 어느 세대의 idiom인가"를 의식해야 한다. 오래된 코드베이스를 유지보수할 때는 그 시대의 이디엄을 일관적으로 유지하는 것이 새 세대 이디엄을 섞는 것보다 나을 수도 있다.

이디엄의 출처와 권위

이디엄은 누가 정하는가? 단일한 권위는 없고, 여러 출처가 상호작용하면서 형성된다.

1. 언어 설계자 / 공식 제안
   - Python의 PEP, Rust의 RFC, JS의 TC39 proposal
   - 공식 권장 사항이 이디엄의 출발점

2. 표준 라이브러리의 자기 사용 방식
   - 표준 라이브러리가 자기 API를 어떻게 쓰는지가 사실상 표준
   - Python의 itertools, Go의 io 패키지, Rust의 std 모듈

3. 린터 / 포매터의 기본 규칙
   - rustfmt, gofmt, prettier, eslint, ruff, pylint
   - 자동 적용되므로 사실상 가장 강한 강제력

4. 유명 오픈소스의 사실상 표준
   - React 코드베이스, Django 프로젝트, Kubernetes 소스
   - 큰 프로젝트의 관례가 커뮤니티 전체로 확산

5. 권위 있는 책과 가이드
   - Effective C++, Effective Java, Fluent Python
   - The Rust Book, Real World Haskell
   - Google Style Guide

이 출처들이 충돌할 때(예: rustfmt가 권장하는 형태와 커뮤니티 관행이 다를 때) 무엇을 따를지가 실무 판단의 영역이다. 일반적으로는 (3) 린터/포매터 > (2) 표준 라이브러리 > (1) 공식 제안 순으로 강한 강제력을 가지며, (4)와 (5)는 맥락에 따라 비중이 다르다.

이디엄은 언어의 철학을 드러낸다

언어마다 이디엄이 다른 이유는 문법이 달라서만이 아니다. 언어가 장려하는 사고방식이 다르기 때문이다.

Python:     명확함, 간결함, 동적 프로토콜
C++:        자원 수명, 값 의미, 비용 모델
Java:       명시적 타입, 인터페이스, 객체 모델
JavaScript: 함수 값, 비동기 이벤트, 객체 리터럴
Rust:       소유권, 빌림, 명시적 오류 처리
Go:         단순한 제어 흐름, 명시적 에러 반환
Haskell:    순수성, 타입, 합성

따라서 한 언어의 이디엄을 다른 언어에 그대로 가져오면 어색해진다.

Java식 class hierarchy를 Python에 그대로 옮기면 과하게 무겁다.
Python식 duck typing을 Java에 그대로 옮기면 타입 시스템과 충돌한다.
C++식 수명 제어 감각 없이 C++ 코드를 쓰면 자원 누수가 난다.
JavaScript식 동적 객체 감각을 Rust에 그대로 가져오면 소유권 모델과 충돌한다.
Haskell식 함수 합성을 Java에 그대로 옮기면 어색한 functional interface 폭증으로 끝난다.

좋은 이디엄의 조건

좋은 이디엄은 단순히 짧은 코드가 아니다.

좋은 이디엄 =
언어가 제공하는 안전장치를 활용하고
생태계가 기대하는 형태를 따르며
코드의 의도를 빠르게 드러내는 표현

좋은 이디엄은 다음 성질을 가진다.

• 읽는 사람이 의도를 즉시 파악할 수 있다.

• 표준 라이브러리와 잘 맞는다.

• 예외, 자원 해제, 동시성 같은 위험 지점을 줄인다.

• 도구, 린터, 타입체커, 포매터와 잘 맞는다.

• 불필요한 추상화를 만들지 않는다.

학습 방법

이디엄은 문법 책만으로 익히기 어렵다. 실제 생태계의 표준 코드를 읽고, 능동적으로 질문해야 한다.

1. 공식 문서의 예제와 자기 사용 방식 보기
2. 표준 라이브러리 사용 패턴 분석
3. 유명 오픈소스의 작은 모듈 읽기
4. 린터와 포매터가 권장하는 형태 확인
5. Effective X, The * Book류 권위 있는 가이드 읽기
6. "왜 이 언어에서는 이렇게 쓰는가"를 항상 질문하기

이디엄을 배울 때 핵심 질문:

이 언어에서는 자원 수명을 어떻게 표현하는가?
오류를 어떻게 표현하는가? (예외, Result, errno, panic)
반복과 컬렉션 처리는 어떻게 쓰는가?
추상화 단위는 함수인가, 객체인가, trait인가, interface인가?
동시성과 비동기는 어떤 방식이 자연스러운가?
모듈 경계는 어디에 그어지는가?

이 질문들을 일관적으로 적용하면 새 언어의 이디엄을 빠르게 흡수할 수 있다.

연구 동향

이디엄은 정성적 개념이지만, 최근에는 소스 코드 마이닝을 통해 정량적으로 추출하려는 시도도 있다. Allamanis와 Sutton(2014)은 GitHub의 대규모 코드베이스에서 통계적 방법으로 반복되는 패턴 조각을 자동 추출하는 연구를 발표했고, 이를 "mining idioms from source code"라고 명명했다.[1]

이러한 자동 추출은 새로 학습하는 언어의 관용 표현을 빠르게 파악하거나, 코드 리뷰 도구가 anti-idiom을 탐지하는 기반으로 활용될 수 있다. 다만 통계적으로 빈번한 표현이 반드시 idiomatic하다고 단정할 수는 없으며, 권위 있는 출처와의 교차 검증이 필요하다.

또한 크라우드소싱 개발 환경에서 이디엄 학습의 장벽이 어떻게 작동하는지에 대한 인지적 연구도 진행되었다.[2]

요약

프로그래밍 이디엄은 특정 언어에서 자연스럽다고 여겨지는 작은 코드 표현 관례다.

패러다임은 사고방식을 정한다.
원칙은 판단 기준을 정한다.
패턴은 반복 문제의 해법을 정한다.
이디엄은 자연스러운 표현을 정한다.
문법은 가능한 표현 규칙을 정한다.

좋은 개발자는 단순히 문법을 아는 사람이 아니라, 그 언어의 이디엄을 통해 문제를 자연스럽게 표현할 줄 아는 사람이다. 이디엄은 시대에 따라 바뀌고, 출처가 분산되어 있으며, 명시적인 음의 예시(anti-idiom)와 짝을 이룬다. 이 세 가지 차원을 모두 의식하면 새 언어를 만났을 때 적응 속도가 크게 달라진다.

같이 보기

• 디자인 패턴

• 소프트웨어 디자인 패턴

• 객체지향 프로그래밍

• 프로그래밍 패러다임

• 함수형 프로그래밍

• RAII

• 표준 관용구

• Idiomatic 코드

• Pythonic

• Modern C++

• Idiomatic Rust

• 상속보다 합성

• 언어적 관용구

• 인지 부담

• 알고리즘 스켈레톤

• Embedded SQL

외부 링크

• Programming-Idioms.org - 언어별 이디엄 비교 데이터베이스

• Wikipedia: Programming idiom

분류: 프로그래밍 | 프로그래밍 언어 | 소프트웨어 공학 | WIKI