제너레이터와 이터레이터로 메모리 효율과 지연 평가를 극대화하는 법

데이터 처리의 효율성은 현대 소프트웨어 개발에서 핵심적인 경쟁력입니다. 특히 대규모 데이터를 다루거나, 무한한 시퀀스를 처리해야 할 때, 단순히 모든 데이터를 메모리에 올리는 방식은 성능 저하와 메모리 부족이라는 치명적인 문제를 야기할 수 있습니다. 오늘은 이러한 문제를 우아하게 해결해주는 파이썬과 자바스크립트의 강력한 도구, 제너레이터(Generator)와 이터레이터(Iterator)에 대해 깊이 있게 알아보겠습니다. 이 개념들을 정확히 이해하고 활용하는 것은 여러분의 코드를 더욱 견고하고 효율적으로 만드는 데 필수적입니다.

개념 소개: 데이터 스트림을 다루는 우아한 방법

이터러블, 이터레이터, 그리고 제너레이터의 정의

개발자라면 한 번쯤 for 루프를 사용해봤을 것입니다. for item in collection: 구문에서 collection은 바로 이터러블(Iterable) 객체입니다. 이터러블은 __iter__() (파이썬) 또는 Symbol.iterator (자바스크립트) 메서드를 가지고 있어, 호출될 때 이터레이터(Iterator) 객체를 반환합니다.

이터레이터는 데이터 스트림을 순회하는 데 사용되는 객체입니다. 이터레이터는 __next__() (파이썬) 또는 next() (자바스크립트) 메서드를 가지고 있으며, 이 메서드를 호출할 때마다 시퀀스의 다음 요소를 반환합니다. 더 이상 반환할 요소가 없으면 StopIteration 예외(파이썬)를 발생시키거나 { value: undefined, done: true } 객체(자바스크립트)를 반환하여 순회가 끝났음을 알립니다. 핵심은 이터레이터가 '현재 위치'를 기억하고 있다는 점입니다.

제너레이터는 이터레이터를 생성하는 특별한 종류의 함수입니다. 일반 함수가 return을 만나면 한 번 실행되고 종료되는 반면, 제너레이터 함수는 yield 키워드를 사용하여 값을 반환하고, 동시에 자신의 실행 상태를 일시 정지합니다. 다음에 next()가 호출되면, 제너레이터는 이전에 멈췄던 지점부터 실행을 재개합니다. 이렇게 yield 키워드를 포함하는 함수를 제너레이터 함수라고 하며, 이 함수를 호출하여 반환되는 객체를 제너레이터 객체라고 부릅니다. 제너레이터 객체는 그 자체가 이터레이터입니다.

탄생 배경: 대규모 데이터 처리의 필요성

제너레이터와 이터레이터 개념은 주로 대규모 데이터 처리, 무한 시퀀스 생성, 그리고 메모리 효율성이라는 문제들을 해결하기 위해 탄생했습니다.

메모리 제약: 수십 기가바이트 또는 테라바이트에 달하는 로그 파일, CSV 파일, 데이터베이스 쿼리 결과 등을 한 번에 메모리에 로드하는 것은 불가능하거나 비효율적입니다.
무한 시퀀스: 피보나치 수열처럼 논리적으로 무한한 시퀀스를 다룰 때, 모든 요소를 미리 생성해둘 수 없습니다. 필요한 시점에 필요한 만큼만 생성해야 합니다.
지연 평가 (Lazy Evaluation): 모든 계산을 즉시 수행하는 대신, 결과가 실제로 필요할 때까지 계산을 미루는 방식이 효율적일 때가 많습니다. 이는 불필요한 연산을 줄이고 시작 시간을 단축시킵니다.

이러한 배경에서, 데이터를 '요청 시'에만 생성하고 소비하는 스트리밍 방식의 처리가 중요해졌고, 이를 가능하게 하는 핵심 도구가 바로 제너레이터와 이터레이터입니다.

왜 중요한가: 효율성과 유연성

제너레이터와 이터레이터는 다음과 같은 이유로 개발자에게 매우 중요합니다.

메모리 효율성: 모든 데이터를 한 번에 메모리에 로드하지 않고, 필요할 때마다 하나씩 생성하여 제공하므로 메모리 사용량을 획기적으로 줄일 수 있습니다. 이는 특히 임베디드 시스템, 서버리스 환경, 빅데이터 처리 등 자원이 제한되거나 대규모 데이터를 다루는 환경에서 필수적입니다.
지연 평가: 데이터가 실제로 사용될 때까지 생성을 미루기 때문에, 불필요한 계산을 방지하고 프로그램의 시작 시간을 단축시킬 수 있습니다.
무한 시퀀스 처리: 무한한 데이터 스트림(예: 네트워크 패킷 스트림, 실시간 센서 데이터, 로그 데이터)을 마치 유한한 리스트처럼 다룰 수 있게 해줍니다.
코드 간결성 및 가독성: 복잡한 상태 관리나 콜백 함수 없이도 순차적인 데이터 처리를 마치 동기 코드처럼 자연스럽게 작성할 수 있습니다. 이는 비동기 프로그래밍 패턴에서도 강력한 이점을 제공합니다.
파이프라인 구축: 여러 제너레이터를 연결하여 데이터 처리 파이프라인을 쉽게 구축할 수 있습니다. 각 제너레이터는 이전 제너레이터의 출력을 받아 처리하고 다음 제너레이터로 전달하는 역할을 수행합니다.

핵심 원리 설명: '주문 시 생산' 공장 비유

이터러블, 이터레이터, 제너레이터의 관계를 이해하기 위해 '주문 시 생산되는 공장' 비유를 들어보겠습니다.

리스트/배열 (일반적인 컬렉션): 마치 모든 상품이 미리 만들어져 창고에 보관되어 있는 것과 같습니다. 고객(for 루프)이 어떤 상품을 요청하든, 창고에서 즉시 꺼내줄 수 있습니다. 편리하지만, 창고 공간(메모리)이 많이 필요하고, 모든 상품을 미리 만들어야 하는 초기 비용(시간)이 듭니다.
이터러블 (창고의 개념): "나는 내가 어떤 상품들을 가지고 있는지 알려줄 수 있어. 네가 원하면 상품을 하나씩 꺼내주는 방법을 알려줄게."라고 말하는 창고의 대리인입니다.
이터레이터 (창고 관리자): 이터러블이 "상품을 하나씩 꺼내주는 방법"으로 건네준 사람입니다. 이 관리자는 "다음 상품 주세요!"라고 요청(next() 호출)할 때마다, 창고에서 다음 상품을 찾아 건네줍니다. 이 관리자는 자신이 어디까지 상품을 꺼내줬는지 기억하고 있습니다.
제너레이터 (주문 시 생산 공장): 이 공장은 미리 상품을 만들지 않습니다. 고객(for 루프)이 "상품 하나 주세요!"라고 주문(next() 호출)하면, 그제서야 상품 하나를 생산해서 건네줍니다. 그리고 다음 주문이 들어올 때까지 생산 라인을 잠시 멈춥니다. 이 공장은 자신이 어떤 상품까지 만들었는지, 다음에는 뭘 만들어야 하는지 정확히 기억하고 있습니다.

이 비유에서 제너레이터가 얼마나 메모리 효율적인지 이해할 수 있습니다. 수억 개의 상품을 미리 만들어 창고에 쌓아둘 필요 없이, 주문이 들어올 때마다 하나씩 생산하므로, 대규모 데이터를 다루는 데 매우 적합합니다.

`yield` 키워드의 마법

제너레이터의 핵심은 바로 yield 키워드입니다. yield는 값을 반환하는 동시에 함수의 실행 상태를 일시 정지시킵니다. 다음 next() 호출이 들어오면, 함수는 yield 다음 줄부터 실행을 재개합니다.

graph TD
    A[제너레이터 함수 호출] --> B{제너레이터 객체 생성};
    B --> C[next() 호출];
    C --> D{함수 실행 시작 또는 재개};
    D --> E{yield 값};
    E --> F[값 반환 후 일시 정지];
    F --> C;
    E --> G{함수 끝 or return};
    G --> H[StopIteration 발생];

이 다이어그램은 제너레이터의 실행 흐름을 보여줍니다. next()가 호출될 때마다 yield까지 실행되고 값이 반환되며, 함수는 그 상태로 멈춥니다. 다음 next() 호출은 중단된 지점부터 다시 시작됩니다. 모든 yield가 소진되거나 return 문을 만나면, 제너레이터는 StopIteration을 발생시키고 종료됩니다.

코드 예제: 실제 문제 해결하기

Python 예제: 대규모 파일 처리

대용량 로그 파일에서 특정 패턴을 포함하는 라인을 찾아 처리한다고 가정해봅시다. 파일을 한 번에 읽어 리스트에 저장하는 대신, 제너레이터를 사용하면 메모리 사용량을 최소화할 수 있습니다.

import os

# 예제용 대용량 파일 생성 (실제 환경에서는 이미 존재하는 파일을 사용)
def create_large_log_file(filename, num_lines=1000000):
    print(f"Creating {filename} with {num_lines} lines...")
    with open(filename, 'w') as f:
        for i in range(num_lines):
            if i % 10000 == 0:
                f.write(f"ERROR: Something went wrong at line {i}\n")
            else:
                f.write(f"INFO: This is a log entry for line {i}\n")
    print(f"Finished creating {filename}.")

# 제너레이터를 사용하여 파일 라인을 하나씩 읽는 함수
def read_large_file_generator(filepath):
    """
    대용량 파일을 라인 단위로 읽어들이는 제너레이터.
    파일 전체를 메모리에 로드하지 않고 한 번에 한 라인씩 반환합니다.
    """
    with open(filepath, 'r') as f:
        for line in f:
            yield line.strip() # 각 라인에서 개행 문자 제거 후 반환

# 제너레이터 없이 파일을 한 번에 읽는 함수 (비교용)
def read_large_file_list(filepath):
    """
    대용량 파일을 한 번에 읽어 리스트로 반환하는 함수.
    파일 크기가 크면 메모리 문제가 발생할 수 있습니다.
    """
    with open(filepath, 'r') as f:
        return [line.strip() for line in f]

if __name__ == "__main__":
    log_file = "large_log.txt"
    create_large_log_file(log_file, num_lines=5_000_000) # 5백만 라인 파일 생성

    # 1. 제너레이터 사용 예제
    print("\n--- Using Generator ---")
    error_count_gen = 0
    # 제너레이터는 파일을 열고, 필요한 시점에 라인을 하나씩 읽어들임
    # for 루프는 next()를 암묵적으로 호출
    for line in read_large_file_generator(log_file):
        if "ERROR" in line:
            error_count_gen += 1
            # print(f"Found error: {line}") # 너무 많으므로 주석 처리
        if error_count_gen >= 10: # 예시를 위해 10개만 찾고 중단
            print("Found 10 errors, stopping early.")
            break
    print(f"Total errors found (generator): {error_count_gen}")

    # 2. 리스트 사용 예제 (주의: 메모리 부족 발생 가능성 있음)
    print("\n--- Using List (CAUTION: May consume significant memory) ---")
    try:
        # 이 부분에서 대용량 파일의 경우 메모리 부족이 발생할 수 있음
        # 작은 파일로 테스트하거나, 실제 대용량 파일에서는 실행하지 않는 것을 권장
        # all_lines = read_large_file_list(log_file)
        # error_count_list = sum(1 for line in all_lines if "ERROR" in line)
        # print(f"Total errors found (list): {error_count_list}")
        print("Skipping list example for large file to avoid memory issues.")
    except MemoryError:
        print("MemoryError: Failed to load entire file into memory.")

    # 파일 정리
    os.remove(log_file)
    print(f"\nCleaned up {log_file}.")

이 예제에서 read_large_file_generator 함수는 yield를 사용하여 파일을 한 번에 한 줄씩만 메모리에 로드합니다. 이는 수백만 줄의 파일을 처리할 때 리스트로 모든 라인을 읽어들이는 read_large_file_list 방식보다 훨씬 효율적입니다. for 루프가 다음 라인을 요청할 때까지 제너레이터는 실행을 일시 정지하고 메모리를 점유하지 않습니다.

JavaScript 예제: 비동기 데이터 스트림 처리

자바스크립트의 제너레이터는 async/await 등장 이전에는 비동기 코드를 동기 코드처럼 보이게 하는 데도 많이 사용되었습니다. 지금은 주로 무한 시퀀스, 커스텀 이터러블, 또는 복잡한 비동기 흐름 제어에 활용됩니다.

// 무한 피보나치 수열을 생성하는 제너레이터 함수
function* fibonacciSequence() {
    let a = 0;
    let b = 1;
    while (true) { // 무한 시퀀스
        yield a;
        [a, b] = [b, a + b]; // 다음 피보나치 수 계산
    }
}

// 비동기 데이터 로딩을 흉내내는 제너레이터 함수
async function* fetchDataStream(urls) {
    for (const url of urls) {
        console.log(`Fetching data from: ${url}...`);
        // 실제 네트워크 요청을 비동기적으로 수행
        const response = await fetch(url);
        const data = await response.json();
        yield data; // 데이터 반환 후 일시 정지
        console.log(`Data from ${url} processed.`);
    }
}

async function runExamples() {
    // 1. 피보나치 수열 제너레이터 사용
    console.log("--- Fibonacci Sequence ---");
    const fibGen = fibonacciSequence();
    console.log(fibGen.next().value); // 0
    console.log(fibGen.next().value); // 1
    console.log(fibGen.next().value); // 1
    console.log(fibGen.next().value); // 2
    for (let i = 0; i < 5; i++) {
        console.log(fibGen.next().value); // 3, 5, 8, 13, 21
    }

    // 2. 비동기 데이터 스트림 제너레이터 사용 (가상 URL)
    console.log("\n--- Asynchronous Data Stream ---");
    const dummyUrls = [
        'https://jsonplaceholder.typicode.com/todos/1',
        'https://jsonplaceholder.typicode.com/todos/2',
        'https://jsonplaceholder.typicode.com/todos/3'
    ];
    const dataStream = fetchDataStream(dummyUrls);

    // for-await-of 루프는 비동기 이터러블을 순회할 때 사용
    for await (const data of dataStream) {
        console.log("Received data:", data);
        if (data.id === 2) {
            console.log("Found data with ID 2, stopping early.");
            break; // 중간에 처리 중단 가능
        }
    }
    console.log("Finished processing data stream.");
}

runExamples();

자바스크립트 예제에서는 fibonacciSequence 제너레이터가 무한한 피보나치 수열을 메모리 부담 없이 생성합니다. fetchDataStream은 async와 yield를 함께 사용하여 비동기 작업을 순차적으로 수행하면서도, 각 데이터가 도착할 때마다 일시 정지하고 필요에 따라 처리할 수 있게 합니다. for await...of 구문은 비동기 제너레이터를 순회하는 강력한 방법입니다.

실무 적용 사례: 다양한 활용처

제너레이터와 이터레이터는 생각보다 훨씬 다양한 실무 시나리오에서 빛을 발합니다.

대규모 데이터 처리 및 스트리밍:
- 로그 파일 파싱: 수십 기가바이트의 서버 로그 파일에서 특정 오류 메시지를 찾거나 통계를 생성할 때, 파일을 한 줄씩 읽어 처리하여 메모리 오버플로우를 방지합니다.
- CSV/JSON 파일 처리: 대용량 CSV 파일을 로드하여 분석하거나, 웹 API에서 스트리밍되는 JSON 데이터를 파싱할 때 효율적입니다.
- 데이터베이스 쿼리 결과: ORM이나 데이터베이스 커넥터에서 수백만 건의 쿼리 결과를 한 번에 가져오는 대신, 제너레이터를 통해 레코드를 하나씩 가져와 처리할 수 있습니다.
API 및 웹 서비스:
- 무한 스크롤/페이징: 웹 애플리케이션에서 무한 스크롤 UI를 구현할 때, 서버에서 페이지 단위로 데이터를 가져오는 제너레이터 함수를 사용하여 클라이언트에 제공할 수 있습니다.
- 실시간 데이터 스트리밍: WebSocket 등을 통해 실시간으로 들어오는 데이터를 처리하는 파이프라인을 구축할 때 유용합니다.
알고리즘 및 자료구조:
- 무한 시퀀스 생성: 피보나치 수열, 소수 시퀀스 등 무한하거나 매우 긴 시퀀스를 필요에 따라 생성할 때 사용합니다.
- 그래프/트리 순회: 깊이 우선 탐색(DFS)이나 너비 우선 탐색(BFS)과 같은 그래프 순회 알고리즘을 제너레이터로 구현하여, 모든 노드를 미리 계산하지 않고 순회할 수 있습니다.
비동기 프로그래밍 (과거 JavaScript):
- async/await이 표준화되기 전에는 제너레이터와 co 같은 라이브러리를 사용하여 비동기 코드를 동기 코드처럼 작성하는 패턴이 널리 사용되었습니다. 현재는 async/await이 더 선호되지만, 비동기 제너레이터는 여전히 강력한 도구입니다.
테스트 데이터 생성:
- 대량의 가짜 데이터를 테스트에 사용할 때, 제너레이터를 이용하면 필요한 만큼만 데이터를 생성하여 메모리를 절약하고 테스트 속도를 향상시킬 수 있습니다.

자주 하는 실수와 해결법: 오해 바로잡기

제너레이터와 이터레이터는 강력하지만, 몇 가지 흔한 오해와 실수들이 있습니다.

실수 1: 제너레이터 객체를 한 번 소진하면 재사용할 수 있다고 오해

가장 흔한 실수 중 하나입니다. 제너레이터 객체는 이터레이터이며, 한 번 순회하여 모든 값을 소진하면 다시는 값을 생성하지 않습니다. 마치 한 번 읽고 버려지는 신문과 같습니다.

def my_generator():
    yield 1
    yield 2

gen = my_generator()
print(list(gen)) # [1, 2]
print(list(gen)) # [] - 이미 소진되어 아무것도 나오지 않음

해결법: 제너레이터를 다시 사용해야 할 경우, 제너레이터 함수를 다시 호출하여 새로운 제너레이터 객체를 생성해야 합니다.

gen1 = my_generator()
print(list(gen1)) # [1, 2]

gen2 = my_generator() # 새로운 제너레이터 객체 생성
print(list(gen2)) # [1, 2]

실수 2: `return`과 `yield`의 혼동

제너레이터 함수에서 return을 사용하면 해당 제너레이터의 실행이 즉시 종료되고 StopIteration이 발생합니다. yield는 값을 반환하고 실행을 일시 정지하지만, 함수는 종료되지 않습니다.

def mixed_generator(n):
    for i in range(n):
        if i == 2:
            return "Early exit!" # 이 값을 직접 반환하지는 않음, StopIteration의 value로 사용될 수 있음
        yield i

gen = mixed_generator(5)
print(next(gen)) # 0
print(next(gen)) # 1
try:
    print(next(gen)) # StopIteration 발생
except StopIteration as e:
    print(f"Generator stopped: {e.value}") # Python 3.3+에서는 return 값도 받아올 수 있음

해결법: 제너레이터에서 값을 반환하고 싶다면 yield를 사용하고, 제너레이터의 실행을 완전히 끝내고 싶다면 return을 사용하세요. return 뒤에 오는 값은 StopIteration 예외의 value 속성으로 접근할 수 있으나, 일반적으로 제너레이터의 '결과 값'으로 기대하지 않습니다.

실수 3: 모든 상황에 제너레이터를 사용하는 것이 좋다고 오해

제너레이터는 메모리 효율적이지만, 항상 최선의 선택은 아닙니다. 작은 데이터셋에서는 리스트나 배열을 사용하는 것이 오히려 더 빠르고 간결할 수 있습니다. 제너레이터는 상태를 유지하고 next() 호출마다 컨텍스트 스위칭이 발생하므로, 오버헤드가 존재합니다.

해결법: 데이터셋의 크기, 메모리 제약, 그리고 데이터가 실제로 한 번만 사용되는지 여부를 고려하여 선택해야 합니다.

데이터가 한 번만 순회되고, 크기가 매우 크다면 → 제너레이터
데이터가 여러 번 순회되어야 하거나, 크기가 작다면 → 리스트/배열

실수 4: 제너레이터 표현식(Generator Expression)과 리스트 컴프리헨션(List Comprehension)의 차이점 혼동 (Python)

# 리스트 컴프리헨션 (즉시 평가, 리스트 생성)
squares_list = [x*x for x in range(1000000)] # 100만 개의 제곱수를 즉시 메모리에 저장

# 제너레이터 표현식 (지연 평가, 제너레이터 객체 생성)
squares_gen = (x*x for x in range(1000000)) # 제너레이터 객체만 생성, 값은 필요할 때마다 생성

해결법: 괄호 ()를 사용하면 제너레이터 표현식(지연 평가)이 되고, 대괄호 []를 사용하면 리스트 컴프리헨션(즉시 평가)이 됩니다. 대용량 데이터를 다룰 때는 제너레이터 표현식을 사용하여 메모리를 절약하세요.

더 공부할 리소스 추천

제너레이터와 이터레이터의 개념을 마스터하는 것은 파이썬과 자바스크립트 개발자로서 한 단계 더 성장하는 중요한 발판이 될 것입니다. 다음 리소스들을 통해 더 깊이 탐구해보세요.

Python:
- itertools 모듈: 파이썬의 itertools 모듈은 이터레이터를 생성하고 조합하는 데 유용한 함수들을 제공합니다. count(), cycle(), repeat(), chain(), groupby(), permutations(), combinations() 등 다양한 함수들을 익히면 데이터 처리 파이프라인을 더욱 강력하게 구축할 수 있습니다.
- PEP 255 -- Simple Generators: 파이썬 제너레이터의 초기 디자인 문서를 읽어보면 개념의 탄생 배경을 이해하는 데 도움이 됩니다.
- Python 공식 문서 - Iterators와 Generators: https://docs.python.org/3/tutorial/classes.html#iterators
JavaScript:
- MDN Web Docs - Iteration protocols: 자바스크립트의 이터레이션 프로토콜(Symbol.iterator, next())에 대한 자세한 설명과 예제를 제공합니다. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
- MDN Web Docs - function* (generator functions): 제너레이터 함수에 대한 상세한 가이드입니다. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*
- Async Generators: async function*을 사용하여 비동기 이터레이터를 만드는 방법을 학습하세요. 비동기 데이터 스트림 처리에 매우 유용합니다.

이러한 개념들을 잘 이해하고 적용한다면, 여러분은 더 효율적이고 유연하며 확장 가능한 소프트웨어를 개발할 수 있을 것입니다. 지금 바로 여러분의 코드에 제너레이터와 이터레이터를 적용해보세요!

개념 소개: 데이터 스트림을 다루는 우아한 방법

이터러블, 이터레이터, 그리고 제너레이터의 정의

탄생 배경: 대규모 데이터 처리의 필요성

왜 중요한가: 효율성과 유연성

핵심 원리 설명: '주문 시 생산' 공장 비유

`yield` 키워드의 마법

코드 예제: 실제 문제 해결하기

Python 예제: 대규모 파일 처리

JavaScript 예제: 비동기 데이터 스트림 처리

실무 적용 사례: 다양한 활용처

자주 하는 실수와 해결법: 오해 바로잡기

실수 1: 제너레이터 객체를 한 번 소진하면 재사용할 수 있다고 오해

실수 2: `return`과 `yield`의 혼동

실수 3: 모든 상황에 제너레이터를 사용하는 것이 좋다고 오해

실수 4: 제너레이터 표현식(Generator Expression)과 리스트 컴프리헨션(List Comprehension)의 차이점 혼동 (Python)

더 공부할 리소스 추천

의존성 주입(Dependency Injection)으로 견고하고 테스트하기 쉬운 코드 만들기

비동기 프로그래밍 오해 바로잡기: `async/await`는 멀티스레딩이 아닙니다

개념 소개: 데이터 스트림을 다루는 우아한 방법

이터러블, 이터레이터, 그리고 제너레이터의 정의

탄생 배경: 대규모 데이터 처리의 필요성

왜 중요한가: 효율성과 유연성

핵심 원리 설명: '주문 시 생산' 공장 비유

yield 키워드의 마법

코드 예제: 실제 문제 해결하기

Python 예제: 대규모 파일 처리

JavaScript 예제: 비동기 데이터 스트림 처리

실무 적용 사례: 다양한 활용처

자주 하는 실수와 해결법: 오해 바로잡기

실수 1: 제너레이터 객체를 한 번 소진하면 재사용할 수 있다고 오해

실수 2: return과 yield의 혼동

실수 3: 모든 상황에 제너레이터를 사용하는 것이 좋다고 오해

실수 4: 제너레이터 표현식(Generator Expression)과 리스트 컴프리헨션(List Comprehension)의 차이점 혼동 (Python)

더 공부할 리소스 추천

의존성 주입(Dependency Injection)으로 견고하고 테스트하기 쉬운 코드 만들기

비동기 프로그래밍 오해 바로잡기: `async/await`는 멀티스레딩이 아닙니다

`yield` 키워드의 마법

실수 2: `return`과 `yield`의 혼동