<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kiwon Lee (이기원) on Medium]]></title>
        <description><![CDATA[Stories by Kiwon Lee (이기원) on Medium]]></description>
        <link>https://medium.com/@jazzbach?source=rss-fcc33dd70f8d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*1qoYoz7lXnShcWVdQPzuZw.jpeg</url>
            <title>Stories by Kiwon Lee (이기원) on Medium</title>
            <link>https://medium.com/@jazzbach?source=rss-fcc33dd70f8d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 05:45:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jazzbach/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[도메인 모델과 JPA]]></title>
            <link>https://medium.com/@jazzbach/%EB%8F%84%EB%A9%94%EC%9D%B8-%EB%AA%A8%EB%8D%B8%EA%B3%BC-jpa-e1d602b4a526?source=rss-fcc33dd70f8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/e1d602b4a526</guid>
            <category><![CDATA[domain-model]]></category>
            <category><![CDATA[spring-framework]]></category>
            <category><![CDATA[jpa]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <dc:creator><![CDATA[Kiwon Lee (이기원)]]></dc:creator>
            <pubDate>Sun, 06 Jul 2025 09:23:35 GMT</pubDate>
            <atom:updated>2025-07-06T09:39:06.661Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*arhfeRmX49a2WpGPcqSDWw.png" /></figure><h3>들어가기 전에</h3><p>도메인 모델과 영속 모델을 분리해야 할까? 지난 몇 년 동안 도메인 모델링을 할 때마다 이 문제를 진지하게 고민해왔다. 이를테면 JPA의 @Entity annotation이 붙은 클래스를 도메인 모델로 사용하는 것이 적절한가? 적절하지 않다면 어느 시점에 분리하는 게 좋을까?</p><p>시작하기 전에, 내가 ORM 혐오자가 아니라는 것을 미리 밝혀둔다. 여러 프로젝트에 걸쳐 JPA를 잘 사용하고 있다. 다만 JPA 사용을 당연하게 여기는 흐름에는 반대한다. 모든 프로젝트와 모듈에 일괄적으로 JPA를 적용하는 것에 반대한다. 모두가 JPA를 필수로 학습해야 한다며 FOMO를 조장하는 부트캠프나 온라인 클래스 마케팅에 반대한다.</p><p>오래전 처음 Hibernate를 접했을 땐 그걸로 뭐든지 다 할 수 있을 것만 같았다. ORM을 잘 써서 잘된 적도 많고, 잘못 써서 고생한 적도 많다. <strong>다만 남들이 나와 같은 실수를 하지 않기를 바랄 뿐</strong>이다.</p><p>코드로 뛰어들기 전에, 비슷하지만 다른 개념, <strong>도메인 엔터티</strong>와 <strong>영속 엔터티</strong>의 차이부터 살펴보자. 사실과 다르다면 댓글로 알려주시길 바란다.</p><h3>Domain Entity &amp; Persistence Entity</h3><p>“Entity”라는 같은 단어를 쓰고 있지만 개념적으로 다소 차이가 있다는 점을 짚고 넘어가고 싶다. 어원을 살펴보면 <a href="https://dl.acm.org/doi/10.1145/320434.320440">Entity-Relationship 모델링에 대한 Peter Chen의 논문(1976)</a>이 있다. 하지만 이 논문에서는 OOP에서 말하는 것과 같은 객체의 “행위”는 언급되지 않고 주로 정적인 데이터 구조 측면에서만 언급한다. 그렇다면 우리가 말하는 “도메인 엔터티”라는 용어는 어디에서 기원했을까? 다음과 같이 구분할 수 있다.</p><h4>Domain Entity — DDD(Eric Evans)의 관점</h4><ul><li>에릭 에반스의 책 <a href="https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215">Domain Driven Design(2003)</a>에서 유래.</li><li>단순히 데이터의 집합체가 아니라, <strong>비즈니스 도메인 내에서 고유의 정체성과 라이프사이클을 지니며, 해당 도메인의 규칙과 행위를 캡슐화하는 객체</strong></li><li>기존에 통용되던 Entity의 개념을 확장.</li></ul><h4>Persistence Entity — Object-Relational Mapping(ORM) 관점</h4><ul><li><strong>데이터 영속성을 위한 객체로, 데이터베이스 테이블의 행을 표현.</strong></li><li>도메인 로직보다는 데이터 모델링과 객체-관계 매핑(ORM) 측면에서 정의된 클래스.</li><li>가장 가까운 직계 조상은 <a href="https://docs.oracle.com/cd/A97335_02/apps.102/a83725/entity4.htm">Entity Bean(EJB)</a>.</li><li>JPA의 @Entity annotation이 붙은 클래스.</li><li>주로 데이터의 저장 및 조회에 초점을 맞추며, 애플리케이션에서 영속 상태를 관리하는 역할.</li></ul><p>우리는 상황에 따라 하나의 모델을 Domain Entity 겸 Persistence Entity로 사용할 수도 있고, 완전히 분리할 수도 있다. 장단점을 따져보고 적용 시나리오를 살펴보자.</p><h3>E-Commerce 장바구니 Aggregate 예제 소개</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rd2ohXqHhIRfckX1ozpnew.png" /></figure><p>이커머스의 장바구니 Aggregate를 UML Class Diagram으로 표현했다. 객체 생성 후 변경이 불가능한 속성에 대해서(read-only) 주석을 달아뒀다. 두 개의 Entity와 세 개의 Value Object로 구성되어 있는 이 Aggregate의 책임은 장바구니에 아이템을 추가, 삭제하고, 아이템의 금액을 계산하는 것이다.</p><p>이제 이 Aggregate를 JPA와 POJO로 구현한 결과를 비교해 보자.</p><h3>도메인 모델과 영속 모델을 분리하지 않은 코드</h3><pre>/**  <br> * Aggregate Root<br> */<br>@Entity  <br>@Table(name = &quot;carts&quot;)  <br>@EntityListeners(AuditingEntityListener.class)  <br>@Getter  <br>@Accessors(fluent = true)  <br>public class Cart {  <br>  <br>    @Id  <br>    @Column(name = &quot;id&quot;, nullable = false)  <br>    private UUID id;  <br>  <br>    @CreatedBy  <br>    @Column(name = &quot;created_by&quot;, nullable = false)  <br>    private String createdBy;  <br>  <br>    @OneToMany(mappedBy = &quot;cart&quot;, cascade = CascadeType.ALL, orphanRemoval = true)  <br>    private List&lt;CartItem&gt; items = new ArrayList&lt;&gt;();  <br>  <br>    @CreatedDate  <br>    @Column(name = &quot;created_at&quot;, nullable = false)  <br>    private LocalDateTime createdAt;  <br>  <br>    @LastModifiedDate  <br>    @Column(name = &quot;last_modified_at&quot;, nullable = false)  <br>    private LocalDateTime lastModifiedAt;  <br>  <br>  <br>    // JPA 스펙상 기본 생성자 필요  <br>    protected Cart() {}  <br>  <br>    private Cart(final UUID uuid) {  <br>        this.id = uuid;  <br>    }  <br>  <br>    public static Cart from(final UUID uuid) {  <br>        Objects.requireNonNull(uuid, &quot;uuid must not be null&quot;);  <br>        return new Cart(uuid);  <br>    }  <br>  <br>    // 장바구니 전체 금액 계산  <br>    public Money totalAmount() {  <br>        return items.stream()  <br>                .map(CartItem::itemTotal)  <br>                .reduce(Money::plus)  <br>                .orElse(Money.of(BigDecimal.ZERO, &quot;KRW&quot;)); // 거래 통화를 하나로 고정한다고 가정 (예: KRW)  <br>    }  <br>  <br>    // 장바구니 아이템을 추가하고 JPA 양방향 연관관계 설정  <br>    public void addItem(final CartItem item) {  <br>        ensureNoDuplicateLineItem(item.productId());  <br>        items.add(item);  <br>        item.setCart(this);  <br>    }  <br>  <br>    public void removeItem(final ProductId productId) {  <br>        final CartItem itemToRemove = getItemBy(productId);  <br>        items.remove(itemToRemove);  <br>    }  <br>  <br>    public void updateItemQty(final ProductId productId, final ItemQty qty) {  <br>        final CartItem itemToUpdate = getItemBy(productId);  <br>        itemToUpdate.updateQty(qty);  <br>    }  <br>  <br>    private void ensureNoDuplicateLineItem(final ProductId productId) {  <br>        findItemBy(productId)  <br>                .ifPresent(lineItem -&gt; {  <br>                    throw new IllegalArgumentException(&quot;cartItem with %s already exists: %s&quot;.formatted(productId, lineItem));  <br>                });  <br>    }  <br>  <br>    private CartItem getItemBy(final ProductId productId) {  <br>        return findItemBy(productId)  <br>                .orElseThrow(() -&gt; new IllegalArgumentException(&quot;cartItem with %s not found&quot;.formatted(productId)));  <br>    }  <br>  <br>    private Optional&lt;CartItem&gt; findItemBy(final ProductId productId) {  <br>        return items.stream()  <br>                .filter(lineItem -&gt; productId.equals(lineItem.productId()))  <br>                .findFirst();  <br>    }  <br>}<br><br>/**  <br> * 자식 Entity: CartItem  <br> */<br> <br>@Entity  <br>@Table(name = &quot;cart_items&quot;)  <br>@Getter  <br>@Accessors(fluent = true)  <br>public class CartItem {  <br>  <br>    @Id  <br>    @Column(name = &quot;id&quot;, nullable = false)  <br>    private UUID id;  <br>  <br>    @Embedded  <br>    private ProductId productId;  <br>  <br>    // Value Object  <br>    @Embedded  <br>    private ItemQty qty;  <br>  <br>    // Value Object  <br>    @Embedded  <br>    private Money unitPrice;  <br>  <br>    // 외래 키로 Cart와 연관관계 설정 (ManyToOne)    @ManyToOne(fetch = FetchType.LAZY, optional = false)  <br>    @JoinColumn(name = &quot;cart_id&quot;)  <br>    private Cart cart;  <br>  <br>    // JPA 스펙상 기본 생성자 필요  <br>    protected CartItem() {}  <br>  <br>    private CartItem(final UUID itemId,  <br>                     final ProductId productId,  <br>                     final ItemQty qty,  <br>                     final Money unitPrice) {  <br>        id = itemId;  <br>        this.productId = productId;  <br>        this.qty = qty;  <br>        this.unitPrice = unitPrice;  <br>    }  <br>  <br>    public static CartItem of(final UUID itemId, final ProductId productId, final ItemQty qty, final Money unitPrice) {  <br>        Objects.requireNonNull(productId, &quot;productId must not be null&quot;);  <br>        Objects.requireNonNull(qty, &quot;qty must not be null&quot;);  <br>        Objects.requireNonNull(unitPrice, &quot;unitPrice must not be null&quot;);  <br>        return new CartItem(itemId, productId, qty, unitPrice);  <br>    }  <br>  <br>    // 개별 아이템의 총 금액 계산  <br>    Money itemTotal() {  <br>        return unitPrice.multiply(qty);  <br>    }  <br>  <br>    // JPA 양방향 연관관계를 위해 필요.  <br>    void setCart(final Cart cart) {  <br>        this.cart = cart;  <br>    }  <br>  <br>    ProductId productId() {  <br>        return productId;  <br>    }  <br>  <br>    void updateQty(final ItemQty qty) {  <br>        this.qty = qty;  <br>    }  <br>}<br><br>@Embeddable  <br>@EqualsAndHashCode  <br>public class ProductId {  <br>  <br>    @Column(name = &quot;product_id&quot;, nullable = false)  <br>    private Integer id;  <br>  <br>    // JPA 스펙상 기본 생성자 필요  <br>    protected ProductId() {}  <br>  <br>    private ProductId(final Integer id) {  <br>        this.id = id;  <br>    }  <br>  <br>    public static ProductId from(final Integer number) {  <br>        if (number == null)  <br>            throw new IllegalArgumentException(&quot;number must not be null&quot;);  <br>        if (number &lt;= 0)  <br>            throw new IllegalArgumentException(&quot;number must be greater than 0&quot;);  <br>        return new ProductId(number);  <br>    }  <br>}<br><br>@Embeddable  <br>@EqualsAndHashCode  <br>public class ItemQty {  <br>  <br>    @Column(name = &quot;qty&quot;, nullable = false)  <br>    private int qty;  <br>  <br>    // JPA 스펙상 기본 생성자 필요  <br>    protected ItemQty() {}  <br>  <br>    private ItemQty(final int value) {  <br>        qty = value;  <br>    }  <br>  <br>    public static ItemQty from(final int value) {  <br>        if (value &lt; 1)  <br>            throw new IllegalArgumentException(&quot;qty must be greater than 0&quot;);  <br>        return new ItemQty(value);  <br>    }  <br>  <br>    public int toInt() {  <br>        return qty;  <br>    }  <br>}<br><br>@Embeddable  <br>@EqualsAndHashCode  <br>public class Money {  <br>  <br>    @Column(name = &quot;amount&quot;, nullable = false)  <br>    private BigDecimal amount;  <br>  <br>    @Column(name = &quot;currency&quot;, nullable = false)  <br>    private String currency;  <br>  <br>    // JPA 스펙상 기본 생성자 필요  <br>    protected Money() {}  <br>  <br>    private Money(final BigDecimal amount, final String currency) {  <br>        this.amount = amount;  <br>        this.currency = currency;  <br>    }  <br>  <br>    public static Money of(final BigDecimal amount, final String currency) {  <br>        Objects.requireNonNull(amount, &quot;amount must not be null&quot;);  <br>        Objects.requireNonNull(currency, &quot;currency must not be null&quot;);  <br>        return new Money(amount, currency);  <br>    }  <br>  <br>    public Money plus(final Money other) {  <br>        if (!currency.equals(other.currency))  <br>            throw new IllegalArgumentException(&quot;currency must be same&quot;);  <br>        return of(amount.add(other.amount), currency);  <br>    }  <br>  <br>    // 금액에 정수 값을 곱해 새로운 Money 객체를 생성  <br>    public Money multiply(final ItemQty qty) {  <br>        return of(amount.multiply(BigDecimal.valueOf(qty.toInt())), currency);  <br>    }  <br>  <br>}</pre><p>JPA로 구현한 도메인 모델이 마음에 드는가? 얼핏 보면 나쁘지 않다. <a href="https://martinfowler.com/bliki/ValueObject.html">Value Object</a>를 사용해서 도메인의 불변 규칙을 적용하고 있고, <a href="https://enterprisecraftsmanship.com/posts/always-valid-domain-model/">각 객체는 잘못된 상태를 가질 수 없다.</a> 그런데 이 모델에는 몇 가지 문제가 있다. 이 클래스는 도메인 모델이라고 하기도 애매하고 영속 모델이라고 하기도 애매한 혼종이다. 어떤 문제가 있는지 알아보자.</p><h4>문제1: 관심사의 분리(Separation of Concerns)를 위반한다</h4><p>도메인 모델은 도메인의 행위를 담당하고, 영속 모델은 객체의 영속화 방식을 다룬다. 도메인의 행위는 본질적 복잡성(Essential Complexity)에 해당하며, 영속화는 우발적 복잡성(Accidental Complexity)을 처리한다. 두 모델은 서로 다른 관심사를 가지고 있다. 이 둘을 혼합하면 어떤 결과가 나타날까? 중요한 도메인의 행위에 집중하기 어려워진다. 리팩터링과 기능 변경에 취약해지며, 저수준 변경(DB 구현 변경 등)이 발생할 때 도메인 모델에도 변경이 전파된다.</p><p>유즈케이스를 생각하기 전에 데이터와 인프라 구현(DB Table)으로 먼저 사고가 고착되는 것은 백엔드 개발자가 반드시 피해야 할 저주이다. 위 코드를 짠 사람은 아마 가장 먼저 테이블의 행과 열을 생각할 수밖에 없었을 것이다. 어쩌면 JPA를 잘 다룬다는 사실에 조금은 뿌듯할지도 모르겠다. 더 심각한 문제는 이 코드를 읽는 사람들까지 <strong>비즈니스의 핵심 규칙과 행위보다 구현 디테일에 더 집중하게 만든다</strong>는 점이다. 코드가 JPA Annotation으로 완전히 도배되어 있는데, 테이블을 생각하지 않는 것은 불가능에 가깝다.</p><p>테스트 시나리오와 비즈니스 로직을 만들기 전에 JPA Annotation부터 붙이는 개발자들을 수없이 봐왔다. 너무 이른 결정을 해버린 탓에 DB와의 Coupling을 만들고, 개발 속도를 떨어뜨리는 것이다.</p><p>게다가 아래처럼 JPA의 원활한 동작을 위해, <strong>도메인과는 전혀 상관없는 로직</strong>이 추가되어야만 한다.</p><pre>public class Cart {<br>    // ...<br>    // 장바구니 아이템을 추가하고 JPA 양방향 연관관계 설정  <br>    public void addItem(final CartItem item) {  <br>        ensureNoDuplicateLineItem(item.productId()); <br>        items.add(item);  //<br>        item.setCart(this);  // 도메인과는 전혀 상관 없는 로직!<br>    }<br><br>class CartItem {<br>    // ...<br>    // JPA 양방향 연관관계를 위해 필요.  <br>    void setCart(final Cart cart) {  <br>        this.cart = cart;  <br>    }  <br>    // ...<br>}</pre><p>Cart와 CartItem은 순환 참조 관계이다. 도메인 관점에서 볼 때, CartItem은 Aggregate Root인 Cart를 알아야 할 필요가 전혀 없다. 그러나 JPA 성능 문제를 피하려면 어쩔 수 없다. (<a href="https://vladmihalcea.com/the-best-way-to-map-a-onetomany-association-with-jpa-and-hibernate/">참조</a>)</p><p>영속성 관점에서 보면, 하나의 도메인 Entity을 이루는 모든 속성이 언제나 하나의 DB 테이블에서 유래한다고 가정할 수 있을까? 아래 같은 경우도 생각해보자.</p><ul><li>원천 데이터가 레거시 테이블이라면? JPA 도메인 모델과 큰 괴리 없이 원활하게 매핑될 수 있을까?</li><li>운영 환경에서 중단 없이 테이블에 컬럼을 추가하기 어렵다면? 신규 테이블을 추가하여 덧대어 써야 한다면?</li></ul><h4>문제2: 객체 생명주기 안에서 불변인 속성이 드러나지 않는다</h4><p>ERD에 어떤 속성이 불변인지 주석(read-only)을 통해 표현했다. 가령 예제의 장바구니 정책에 의하면, 아이템의 수량(qty: ItemQty)은 변경할 수 있지만, 가격(unitPrice: Money)은 변경할 수 없어야 한다.</p><p>그런데 구현하고 나니, final 필드를 컬럼과 매핑할 수 없는 JPA의 한계 때문에 어떤 속성이 불변인지 명시적으로 드러나지 않는다. 심지어 불변 타입으로 모델링해야 하는 Value Object들도 모두 @Embeddable이기 때문에, 불변 필드를 사용할 수 없다.</p><p>하나의 객체가 생성된 후, 생명주기 동안 내부 속성에 대한 변경을 엄격하게 제한하는 것은 대단히 중요하다. OOP 코드 품질의 성패가 달려있다고 봐도 과언이 아니다. 다음과 같은 측면에서 생각해보자.</p><ul><li>코드 가독성 측면에서 좋지 않다. 어떤 속성이 불변인지 아닌지 판단하기 위해서는 그 속성을 사용하는 곳을 다 찾아봐야 사실상 불변(effectively final)인지 아닌지 알 수 있다.</li><li>코드를 읽는 사람은 불변일지 가변일지 모르는 속성이 로직에서 사용될 때마다 계속 신경이 쓰인다. 심리적인 안정감을 얻을 수 없다.</li><li>불변 타입이라는 것을 명시적으로 선언해놓지 않으면, 결국 누군가 객체를 재할당할 것이다. 아무런 가책도 없이.</li></ul><h4>문제3: Lazy Fetching의 함정: 점점 비대해지는 Aggregate</h4><p>Aggregate가 클수록, 컬렉션 속성이 많고 객체 그래프의 depth가 깊을수록 Lazy Fetching의 장점을 <strong>극대화</strong> 할 수 있다. 글쎄, 그런데 과연 그게 좋은 걸까?</p><p>ORM의 Lazy Fetching을 이용하면, 더 큰 Aggregate를 만들 수 있다. 혹시 다음과 같은 생각에 공감한다면, 당신도 내가 빠졌던 함정에 빠진 것일 수 있으니 주의를 당부하고 싶다.</p><blockquote><em>내가 디자인한 도메인 객체의 컬렉션 프로퍼티는 특정 메서드에서만 사용하니까, JPA의 Lazy Fetching을 이용하면 불필요한 select 문이 실행되는 걸 막을 수 있어. 정말 효율적일 것 같아!</em></blockquote><p>요즘엔 위와 비슷한 블로그 포스팅을 많이 접한다. 기본에 대해 진지하게 학습하지 않고 JPA라는 특정 기술의 사용법에만 골몰한 결과인 것 같아 안타깝다.</p><p>불필요한 select가 줄어서 좋은 걸까? 특정 메서드에서만 특정 프로퍼티가 사용된다면, <strong>클래스의 응집도</strong>가 낮은 것은 아닐까? 하나의 Aggregate로 디자인하는 게 맞는 걸까?</p><p>Vaughn Vernon은 “<a href="https://www.amazon.com/Implementing-Domain-Driven-Design-Vaughn-Vernon/dp/0321834577">Implementing Domain-Driven Design(2013)</a>”에서 <strong><em>Design Small Aggregates</em></strong>를 강조한다. 프로젝트의 Aggregate가 점점 커지고 있다면, 언제나 다음 사례를 기억하자.</p><blockquote><em>파생 금융 상품 부분에서 Qi4j를 사용한 한 프로젝트에서, Niclas Hedhman은 그의 팀이 약 70퍼센트의 애그리게잇을 값 타입(Value Object) 속성을 포함한 단 하나의 루트 엔터티만으로 설계할 수 있었다고 보고했다. 남은 30퍼센트에선 총 두 개나 세 개 정도의 엔터티가 필요했다. 이는 모든 도메인 모델이 70/30의 비율로 설계된다는 의미는 아니다. 그렇지만 적어도 높은 비율의 애그리게잇이 루트라는 하나의 엔터티만으로 구성할 수 있음을 알 수 있다.</em></blockquote><blockquote><em>반 버논, 도메인 주도 설계 구현 10장</em></blockquote><p>우리 팀에서 만든 진흙덩어리(Big Ball of Mud) 사례와 리팩터링 과정을 함께 소개하고자 한다. 복잡한 도메인에 JPA를 도입했는데, Annotation을 통해 끊없이 연결되는 엔티티 간 참조로 구성된 진흙덩어리를 만들어버렸다. ORM으로 손쉽게 연관관계를 구성할 수 있는 장점을 남용했을 때 어떤 문제에 직면하게 되는지 보여주는 좋은 사례가 될 것이다.</p><p>사례: <a href="https://medium.com/@woojin8787/%EC%9E%91%EA%B3%A0-%EC%A0%90%EC%A7%84%EC%A0%81%EC%9D%B8-%EB%A6%AC%ED%8C%A9%ED%84%B0%EB%A7%81%EC%9C%BC%EB%A1%9C-%EC%9E%91%EC%9D%80-aggregate-%EC%9D%84-%ED%96%A5%ED%95%98%EC%97%AC-27e06a971e8b">작고 점진적인 리팩터링으로 작은 Aggregate 을 향하여</a></p><h4>JPA Entity를 도메인 모델로 사용할 때의 장점</h4><p>도메인 모델링과 관심사의 분리(SoC) 관점에서 보면 특별한 장점이 없다. 도메인 모델과 영속성 모델 간의 매핑 계층을 직접 구현하지 않아도 된다는 것이 유일한 장점이다. 특히 ORM이 제공하는 변경 감지(Dirty Checking) 기능 없이 하위 엔터티 컬렉션의 특정 요소를 추가하거나 삭제하는 코드를 작성하는 것은 상당히 번거롭다. 다만 최근에는 단순한 매핑 코드를 LLM의 도움을 받아 쉽게 생성할 수 있다. 예를 들어, 아래 코드는 순수 도메인 모델을 JPA 영속성 모델로 매핑하는 코드인데, Claude Code가 불과 몇 초 만에 작성한 것이다.</p><pre>private JpaCart updatePersistenceModel(final Cart cart, final JpaCart jpaCart) {  <br>    jpaCart.lastModifiedAt(cart.lastModifiedAt());  <br>  <br>    // 기존 JPA 아이템들을 ID로 매핑  <br>    final Map&lt;CartItemId, JpaCartItem&gt; existingItemsById = jpaCart.items().stream()  <br>            .collect(toUnmodifiableMap(item -&gt; CartItemId.from(item.id()), Function.identity()));  <br>  <br>    // 도메인 아이템들을 ID로 매핑  <br>    final Map&lt;CartItemId, CartItem&gt; domainItemsById = cart.items().stream()  <br>            .collect(toUnmodifiableMap(CartItem::id, Function.identity()));  <br>  <br>    // 추가할 아이템들 (도메인에는 있지만 JPA에는 없는 것들)  <br>    final List&lt;JpaCartItem&gt; itemsToAdd = cart.items().stream()  <br>            .filter(item -&gt; !existingItemsById.containsKey(item.id()))  <br>            .map(this::mapToPersistenceModel)  <br>            .toList();  <br>  <br>    // 삭제할 아이템들 (JPA에는 있지만 도메인에는 없는 것들)  <br>    final List&lt;JpaCartItem&gt; itemsToRemove = jpaCart.items().stream()  <br>            .filter(item -&gt; !domainItemsById.containsKey(CartItemId.from(item.id())))  <br>            .toList();  <br>  <br>    // 수정할 아이템들 (양쪽에 모두 있는 것들)  <br>    final List&lt;JpaCartItem&gt; itemsToUpdate = jpaCart.items().stream()  <br>            .filter(item -&gt; domainItemsById.containsKey(CartItemId.from(item.id())))  <br>            .toList();  <br>  <br>    // 삭제  <br>    itemsToRemove.forEach(jpaCart::removeItem);  <br>  <br>    // 추가  <br>    itemsToAdd.forEach(jpaCart::addItem);  <br>  <br>    // 수정  <br>    itemsToUpdate.forEach(jpaItem -&gt; {  <br>        final CartItem domainItem = domainItemsById.get(CartItemId.from(jpaItem.id()));  <br>        updatePersistenceModel(domainItem, jpaItem);  <br>    });  <br>  <br>    return jpaCart;  <br>}</pre><p>그래도 추가적인 레이어가 생기니, 분리의 장단점을 잘 따져봐야 한다.</p><h3>도메인 모델과 영속 모델을 분리한 코드</h3><p>자, 이제 POJO(Plain-Old Java Object) 도메인 엔터티를 살펴보자.</p><blockquote>일반적인 정의에 의하면, JPA Entity도 POJO라고 할 수 있다. annotation으로 도배되어 있긴 하지만 프레임워크의 특정 인터페이스나 클래스를 상속하는 것이 아니기 때문이다. EJB3이 처음 나왔을 때, EJB2와는 다르게 <a href="https://docs.oracle.com/cd/E16439_01/doc.1013/e13981/undejbs004.htm">Entity Bean</a> 인터페이스를 구현하지 않아도 되었기 때문에 POJO라는 점을 강조했었다.</blockquote><blockquote>그러나 이 글에서는 의도적으로 JPA Entity를 POJO가 아닌 것으로 분류했다. 특정 클래스를 상속하지 않았지만 프레임워크 의존성이 있고, JPA의 암시적인 동작 의존적인 객체가 되기 때문이다.</blockquote><pre>/**  <br> * Aggregate Root <br> */<br>@Getter  <br>@ToString  <br>@Accessors(fluent = true)  <br>public class Cart {  <br>    private final CartId id;  <br>    private final UserId ownerId;  <br>    private final List&lt;CartItem&gt; items = new ArrayList&lt;&gt;();  <br>    private final LocalDateTime createdAt;  <br>    private LocalDateTime lastModifiedAt;  <br>  <br>    private Cart(final CartId id,  <br>                 final UserId ownerId,  <br>                 final LocalDateTime createdAt,  <br>                 final LocalDateTime lastModifiedAt,  <br>                 final List&lt;CartItem&gt; items) {  <br>        this.id = id;  <br>        this.ownerId = ownerId;  <br>        this.createdAt = createdAt;  <br>        this.lastModifiedAt = lastModifiedAt;  <br>        this.items.addAll(items);  <br>    }  <br>  <br> public static Cart of(final CartId id,  <br>                       final UserId ownerId,  <br>                       final LocalDateTime createdAt) {  <br>     return of(id, ownerId, createdAt, createdAt, List.of());  <br> }<br>  <br>    public static Cart of(final CartId id,  <br>                          final UserId ownerId,  <br>                          final LocalDateTime createdAt,  <br>                          final LocalDateTime lastModifiedAt,  <br>                          final List&lt;CartItem&gt; items) {  <br>        Objects.requireNonNull(id, &quot;id must not be null&quot;);  <br>        Objects.requireNonNull(ownerId, &quot;ownerId must not be null&quot;);  <br>        Objects.requireNonNull(createdAt, &quot;createdAt must not be null&quot;);  <br>        Objects.requireNonNull(lastModifiedAt, &quot;lastModifiedAt must not be null&quot;);  <br>        Objects.requireNonNull(items, &quot;items must not be null&quot;);  <br>        return new Cart(id, ownerId, createdAt, lastModifiedAt, items);  <br>    }  <br>  <br>    // 장바구니 아이템을 추가  <br>    public void addItem(final CartItem item, final LocalDateTime now) {  <br>        ensureNoDuplicateLineItem(item.productId());  <br>        items.add(item);  <br>        updateLastModifiedTime(now);  <br>    }  <br>  <br>    // 장바구니 전체 금액 계산  <br>    public Money totalAmount() {  <br>        return items.stream()  <br>                .map(CartItem::itemTotal)  <br>                .reduce(Money::plus)  <br>                .orElse(Money.of(BigDecimal.ZERO, &quot;KRW&quot;)); // 통화를 하나로 고정한다고 가정 (예: KRW)  <br>    }  <br>  <br>    public void removeItem(final ProductId productId, final LocalDateTime now) {  <br>        final CartItem itemToRemove = getItemBy(productId);  <br>        items.remove(itemToRemove);  <br>        updateLastModifiedTime(now);  <br>    }  <br>  <br>    public void updateItemQty(final ProductId productId, final ItemQty qty, final LocalDateTime now) {  <br>        final CartItem itemToUpdate = getItemBy(productId);  <br>        itemToUpdate.updateQty(qty);  <br>        updateLastModifiedTime(now);  <br>    }  <br>  <br>    private void updateLastModifiedTime(final LocalDateTime now) {  <br>        Objects.requireNonNull(now, &quot;createdAt must not be null&quot;);  <br>        lastModifiedAt = now;  <br>    }  <br>  <br>    private void ensureNoDuplicateLineItem(final ProductId productId) {  <br>        findItemBy(productId)  <br>                .ifPresent(lineItem -&gt; {  <br>                    throw new IllegalArgumentException(&quot;cartItem with %s already exists: %s&quot;.formatted(productId, lineItem));  <br>                });  <br>    }  <br>  <br>    private CartItem getItemBy(final ProductId productId) {  <br>        return findItemBy(productId)  <br>                .orElseThrow(() -&gt; new IllegalArgumentException(&quot;cartItem with %s not found&quot;.formatted(productId)));  <br>    }  <br>  <br>    private Optional&lt;CartItem&gt; findItemBy(final ProductId productId) {  <br>        return items.stream()  <br>                .filter(lineItem -&gt; productId.equals(lineItem.productId()))  <br>                .findFirst();  <br>    }  <br>}<br><br>/**  <br> * 자식 Entity: CartItem  <br> */<br>@Getter  <br>@ToString  <br>@Accessors(fluent = true)  <br>public class CartItem {  <br>    private final CartItemId id;  <br>    private final ProductId productId;  <br>    private final Money price;  <br>    private ItemQty qty;  <br>  <br>    private CartItem(final CartItemId id,  <br>                     final ProductId productId,  <br>                     final ItemQty qty,  <br>                     final Money price) {  <br>        this.id = id;  <br>        this.productId = productId;  <br>        this.qty = qty;  <br>        this.price = price;  <br>    }  <br>  <br>    public static CartItem of(final CartItemId id,  <br>                              final ProductId productId,  <br>                              final ItemQty qty,  <br>                              final Money price) {  <br>        Objects.requireNonNull(id, &quot;id must not be null&quot;);  <br>        Objects.requireNonNull(productId, &quot;productId must not be null&quot;);  <br>        Objects.requireNonNull(qty, &quot;qty must not be null&quot;);  <br>        Objects.requireNonNull(price, &quot;price must not be null&quot;);  <br>        return new CartItem(id, productId, qty, price);  <br>    }  <br>  <br>    // 개별 아이템의 총 금액 계산  <br>    Money itemTotal() {  <br>        return price.multiply(qty);  <br>    }  <br>  <br>    void updateQty(final ItemQty qty) {  <br>        Objects.requireNonNull(qty, &quot;qty must not be null&quot;);  <br>        this.qty = qty;  <br>    }  <br>}<br><br>public record ProductId(Integer value) {  <br>  <br>    public static ProductId from(final Integer productId) {  <br>        Objects.requireNonNull(productId, &quot;productId must not be null&quot;);  <br>        if (productId &lt;= 0)  <br>            throw new IllegalArgumentException(&quot;productId must be greater than 0&quot;);  <br>        return new ProductId(productId);  <br>    }  <br>  <br>}<br><br>public record ItemQty(int value) {  <br>  <br>    public static ItemQty from(final int value) {  <br>        if (value &lt; 1)  <br>            throw new IllegalArgumentException(&quot;value must be greater than 0&quot;);  <br>        return new ItemQty(value);  <br>    }  <br>}<br><br>public record Money(BigDecimal amount, String currency) {  <br>  <br>    public static Money of(final BigDecimal amount, final String currency) {  <br>        Objects.requireNonNull(amount, &quot;amount must not be null&quot;);  <br>        Objects.requireNonNull(currency, &quot;currency must not be null&quot;);  <br>        return new Money(amount, currency);  <br>    }  <br>  <br>    Money plus(final Money other) {  <br>        if (!currency.equals(other.currency))  <br>            throw new IllegalArgumentException(&quot;currency must be same&quot;);  <br>        return of(amount.add(other.amount), currency);  <br>    }  <br>  <br>    // 금액에 정수 값을 곱해 새로운 Money 객체를 생성  <br>    Money multiply(final ItemQty qty) {  <br>        return of(amount.multiply(BigDecimal.valueOf(qty.value())), currency);  <br>    }  <br>  <br>}</pre><p>이번에는 어떤가? 코드 가독성 측면에서 훨씬 좋아졌다. 위에 JPA 도메인 모델에서 드러났던 단점들도 개선되었다.</p><ol><li>Separation of Concerns를 준수한다.</li><li>JPA annotation이 없다. 오직 도메인 로직에만 집중할 수 있다.</li><li>객체 생명주기 안에서 불변인 속성이 명확하게 드러난다.</li></ol><p>그뿐일까? 다음과 같은 장점도 있다.</p><h4>프로젝트 초기 테이블 스키마에 대한 결정을 최대한 뒤로 미룰 수 있다</h4><p>테이블 스키마와 같은 본질적 복잡성(Essential Complexity)과 상관없는 구현 세부사항에 대한 결정을 미룰 수 있다면, 좋은 아키텍처를 가졌다고 할 수 있다. 특히 개발 초기 단계에서는 요구사항이 불분명하고 개발자의 도메인 이해도가 낮을 가능성이 높기 때문에, 변경하기 어려운 결정들은 최대한 늦게 내리는 것이 바람직하다.</p><p>개발 초기에는 충분히 시행착오를 겪을 수 있는 유연성을 확보하는 것이 중요하다. 예를 들어, 프로젝트 초반에는 리포지토리를 in-memory 방식으로 구현하는 것만으로도 동작하는 프로토타입을 만들기에 충분하다. 굳이 처음부터 테이블 매핑을 고민할 필요가 없다.</p><pre>interface CartRepository {  <br>  <br>    Optional&lt;Cart&gt; findBy(final UUID id);  <br>  <br>    void save(final Cart cart);  <br>  <br>}<br><br>@Component<br>class CartInMemoryRepository implements CartRepository {  <br>    private final Map&lt;CartId, Cart&gt; carts = new ConcurrentHashMap&lt;&gt;();  <br>  <br>    @Override  <br>    public Optional&lt;Cart&gt; findBy(final CartId id) {  <br>        return Optional.ofNullable(carts.get(id));  <br>    }  <br>  <br>    @Override  <br>    public void save(final Cart cart) {  <br>        carts.put(cart.id(), cart);  <br>    }  <br>}</pre><p>게다가 위와 같이 in-memory 구현으로 만들어진 리포지토리를 사용하면 <strong>매우 빠르게 테스트를 실행할 수 있어 초반 개발 속도도 훨씬 빨라진다.</strong> 초반부터 테스트 컨테이너를 붙이고 DB Connection Pool 설정을 하면 느릴 수밖에 없는 환경을 만들어 놓고 느리게 개발하게 되는 상황에 맞닥뜨릴 것이다.</p><h4>도메인 모델은 더 도메인 모델답게, 영속 모델은 더 영속 모델답게</h4><p>SoC(Separation of Concerns)를 통해 달성할 수 있는 이점이다. 영속 모델이 JPA라면 장바구니 아이템 영속 모델은 다음과 같을 것이다. 도메인 로직은 하나도 없고, Value Object 대신에 그냥 테이블과 행을 표현한 단순한 클래스가 된다.</p><pre>@Entity  <br>@Table(name = &quot;cart_items&quot;)  <br>@Getter  <br>@Setter(AccessLevel.PACKAGE)  <br>@Accessors(fluent = true)  <br>class JpaCartItem {  <br>  <br>    @Id  <br>    @Column(name = &quot;id&quot;, nullable = false)  <br>    private UUID id;  <br>  <br>    @Column(name = &quot;product_id&quot;, nullable = false)  <br>    private Integer productId;  <br>  <br>    @Column(name = &quot;qty&quot;, nullable = false)  <br>    private Integer qty;  <br>  <br>    @Column(name = &quot;amount&quot;, nullable = false)  <br>    private BigDecimal amount;  <br>  <br>    @Column(name = &quot;currency&quot;, nullable = false)  <br>    private String currency;  <br>  <br>    // 외래 키로 Cart와 연관관계 설정 (ManyToOne)<br>    @ManyToOne(fetch = FetchType.LAZY, optional = false)  <br>    @JoinColumn(name = &quot;cart_id&quot;)  <br>    private JpaCart cart;  <br>  <br>    // JPA 스펙상 기본 생성자 필요  <br>    protected JpaCartItem() {}  <br>  <br>}</pre><h4>특정 기술에 종속되지 않는, 기술 선택의 자유</h4><p>ORM을 사용하면 RDBMS 구현으로부터 자유를 누릴 수 있을지는 몰라도, <strong>ORM으로부터 자유로울 수 없다.</strong> 하지만 도메인 모델과 영속 모델을 분리하면, 상황에 따라 얼마든지 다양한 기술을 선택할 수 있다. 이를테면 스프링 프로젝트에서는 상황에 따라 다음과 같은 선택지가 있다.</p><h4>spring-data-jpa</h4><p>JPA Entity를 영속 모델 용도로만 사용한다면, JPA에서 필요한 핵심 기능만 단순하게 사용할 수 있다.</p><h4>spring-data-jdbc</h4><p>JPA의 영속성 컨텍스트 관리 같은 복잡한 내부 동작이 필요 없다면 좋은 선택이 될 것이다.</p><h4>mybatis-spring</h4><p>쿼리를 직접 컨트롤 할 수 있고, 단순하고 직관적이다. 혹시 마이바티스를 쓴다고 무조건 후진 것이라 생각한다면 큰 착각이다. 후진 것은 당신이 경험한 SI식 레거시 코드의 쿼리 남용이지, SQL Mapper는 잘못이 없다.</p><h3>적용 시나리오</h3><p>그럼 언제 도메인 모델과 영속 모델을 같이 쓰거나 분리하는 게 좋을까?</p><h4>도메인 모델과 영속 모델을 분리해야 하는 경우</h4><p>도메인 규칙이 복잡하고 자주 변경된다면 나누는 것이 좋다. 예를 들어 이커머스의 각종 할인 정책(쿠폰, 마일리지 등)은 복잡하고 변경이 잦다. 이런 도메인은 가능한 한 순수하게 유지하여, 테스트 가능성(testability)을 극대화하고 리팩터링을 통해 쉽게 구조를 변경할 수 있도록 해야 한다.</p><p>도메인 모델과 테이블 데이터의 간극이 큰 경우에도 분리하는 것이 좋다. 가령 레거시 프로젝트처럼 이미 테이블이 존재하는 곳에 부분적으로 도메인 모델을 도입하고 싶을 때, 어떻게든 JPA로 매핑해보려고 기를 쓰기보다는 그냥 도메인 모델과 영속 모델을 서로 분리하는 것이 정신 건강에 이롭다. 여러 개의 레거시 테이블을 하나의 도메인 모델로 만들어야 하는 경우를 상상해보자.</p><h4>도메인 모델과 영속 모델을 분리하지 않아도 좋은 경우</h4><p>무조건 분리하는 것이 상책이냐면, 결코 그렇지 않다. 도메인 로직이 별로 없고 단순 CRUD만 하는 경우엔 분리하지 않는 게 좋다. 이 경우, 분리한다면 오히려 쓸데없는 레이어와 매핑만 늘어나, 분리로 얻을 수 있는 이점보다 늘어나는 복잡도가 더 크다. 도메인 로직과 요구사항이 복잡해지고, DB 테이블과의 괴리가 커지기 시작할 때 도메인 모델을 분리하여 진화시키는 것이 최선이다. 물론, 그 시점을 포착할 수 있는 관찰력과 일정 수준 이상의 리팩터링 실력이 있어야 한다.</p><h3>결론</h3><p>이 글을 읽고 당장 도메인 모델과 영속 모델을 분리하고 싶은 사람도 있을 것이고, 그냥 기존 방식을 유지하고 싶은 사람도 있을 것이다. <strong>처음부터 완벽한 선택을 할 필요는 없다</strong>는 점을 강조하고 싶다. 중요한 것은 <strong>변경하기 쉬운 코드로 리팩터링할 수 있는 역량</strong>이다. ORM으로 시작했든 단순한 <a href="https://martinfowler.com/eaaCatalog/transactionScript.html">Transaction Script</a>로 시작했든, 도메인이 복잡해지고 변경이 빈번해진다면 언제든 점진적인 리팩터링을 통해 순수한 도메인 모델을 추출할 수 있어야 한다. 반대로 분리된 구조가 오히려 복잡성만 증가시킨다면 통합하는 방향으로 리팩터링할 수도 있다.</p><p>특정 기술의 사용법을 익히는 것도 중요하지만, 그보다 더 중요한 것은 <strong>왜 그런 선택을 했는지</strong>, <strong>각 선택의 트레이드오프를 명확히 이해하고 현재 상황에서 최선의 판단을 내리는 것</strong>이다. 그리고 그 판단이 틀렸다면 언제든 수정할 수 있는 역량을 기르는 것이다. 팀 동료들과 그 근거를 공유하고 토론할 수 있다면 팀 전체의 역량이 함께 성장할 수 있을 것이다.</p><h3>읽어볼 만한 글</h3><p><a href="https://blog.ploeh.dk/2023/09/18/do-orms-reduce-the-need-for-mapping/"><strong>“Do ORMs reduce the need for mapping?” by Mark Seemann</strong></a></p><ul><li>마크 시먼의 ORM 무용론.</li><li>ORM이 몇 줄의 코드를 줄여줄 수 있지만, 학습비용, 유지보수 비용, 종속성 등의 숨은 비용이 더 크다고 강조.</li><li>댓글에 블라디미르 코리코프의 의견도 흥미로움(Vlad).</li></ul><p><a href="https://enterprisecraftsmanship.com/posts/having-the-domain-model-separate-from-the-persistence-model/"><strong>“Having the domain model separated from the persistence model” by Vladimir Khorikov</strong></a></p><ul><li>“단위 테스트” 책을 쓴 블라디미르 코리코프의 글.</li><li>도메인 모델과 영속 모델의 완전 분리로 인한 복잡성 증가 때문에 분리에 신중한 입장.</li></ul><h3>소스 코드</h3><ul><li><a href="https://github.com/arctrls/cart-example">https://github.com/arctrls/cart-example</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cJi5wfAdgr0_h0SLOZ5sLQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e1d602b4a526" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[커피를 마시는 시간]]></title>
            <link>https://medium.com/@jazzbach/%EC%BB%A4%ED%94%BC%EB%A5%BC-%EB%A7%88%EC%8B%9C%EB%8A%94-%EC%8B%9C%EA%B0%84-ba826ab079c2?source=rss-fcc33dd70f8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba826ab079c2</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Kiwon Lee (이기원)]]></dc:creator>
            <pubDate>Thu, 30 Jan 2025 22:30:16 GMT</pubDate>
            <atom:updated>2025-01-30T22:30:16.585Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jaxji5Uhaic0tjJwk-zZ5g.jpeg" /><figcaption>“You know, this is, — excuse me — a damn fine cup of coffee.”</figcaption></figure><p>하루 중 가장 좋아하는 시간이 있다. 출근 직후와 점심시간 이후, 하루 두 번 팀 동료들과 함께 핸드드립 커피를 마시는 시간이다. 언제부터 시작됐는지는 정확히 기억나지 않는다. 2022년 말 팀장이 되기 전, 입사 초기였다. 몇 차례 큰 서비스 장애를 겪고 눈에 띄는 시스템 문제들을 해결한 후 한숨 돌렸을 때부터였나보다.</p><p>그땐 사무실에 스피커가 있어서 늘 음악을 틀어놨다. 플레이리스트에 있는 음악이 계속 반복해서 흘러나왔다. 그렇게 출근해서, <a href="https://m.youtube.com/watch?v=Fc9fVi-_DWE">세상에서 가장 듣기 싫어진 노래</a>를 대여섯 번 듣고 나면 퇴근할 시간이 되곤 했다.</p><h3>조용한 사무실의 역설</h3><p>칸막이 없는 개방형 사무실, 음악도 있고 겉보기에는 자유로워 보였다. 이대로 괜찮은 걸까? 꽤 내성적인 나조차도 위화감을 느낄 정도로 조용했다. 음악은 다른 <a href="https://www.hani.co.kr/arti/science/future/855192.html">악취</a>를 감추기 위한 방향제 역할을 하고 있었다. 아무도 음악을 듣지 않았고 대부분 이어폰을 끼고 있었다. 일단 음악을 끄자고 건의했다. 그랬더니 정말로 조용해졌다. 가끔 서로 친한 몇 명끼리는 조용히 다가가 툭 치곤 하는 게 보였다. 잠깐 나갔다 오자는 신호를 보내는 모양이었다. 독서실 같군, 하는 생각이 들었다.</p><p>사무실이 조용할수록 더 좋은 걸까? 경험상 꼭 그렇지만은 않다. 특히 비숙련 개발자가 대부분인 팀에서는 손해가 더 많다. 가벼운 잡담도 안 할 정도의 분위기라면 일 이야기도 서로 안 하게(못하게) 된다. 무엇보다도 주니어 개발자들의 눈빛에서 자신감을 볼 수 없었다. 아니, 저때는 잘하든 못하든 <a href="https://en.wikipedia.org/wiki/Dunning%E2%80%93Kruger_effect">자신이 잘났다고 생각할 때</a> 아닌가? 좋지 않은 신호였다. 자신감은커녕 무엇을 해야 할지 전혀 모르는 것 같았다.</p><p>모르면 물어보면 된다, 말처럼 쉬우면 얼마나 좋을까. “궁금한 게 있으면 질문하라”, “할 말이 있으면 하라”. 모두 공허한 말이다. 판결을 앞둔 피고인처럼 분명한 의도를 가지고 있는 사람만이 그런 말에 대답할 수 있다. 상사에게 잘 보이고 싶은 마음을 숨기지 않는 부하직원이라면 마음에 없는 질문이라도 만들어 낼테지만, 누가 그런 형식적인 대화를 원한단 말인가. 한팀으로 일하기 위해서 일단은 서로 조금은 더 친해져야 할 것 같았다. 유대는 억지로 쌓이지 않는다. 하지만 팀원들이 서로 알아갈 수 있는 계기는 반드시 마련되어야 한다.</p><h3>커피 한 잔에서 시작한 변화</h3><p>자주 사용하지 않는 회의실을 잡아 커피를 내리기 시작했다. 때마침 코로나19 유행도 끝나고 사람들이 마스크를 벗기 시작했다. 회사에서 보내는 일과 중 편안하고 즐거운 시간을 만들어보면 분위기가 좀 달라지지 않을까 생각했다. 지금도 마찬가지지만 아쉽게도 우리 회사에는 카페테리아가 없다. 하지만 그런 건 우리에게 장애물이 되지 못했다. 회의실이 없을 땐 창고 같은 공간이라도 상관없었다. 같이 일하던 선배 개발자가 안 쓰던 커피 드립 세트를 회사로 가져왔다. 모든 준비물이 갖춰졌다.</p><p>그렇게 한 번 시작하고 나서, 출근하는 날이면 거의 하루도 빠짐없이 모여서 커피를 내려 마시고 있다. 시작할 때는 소수의 인원이 주도했지만, 지금은 다수의 참여로 유지되고 있다. 꽤 좋은 원두를 고르고 커피 내리는 사람도 점점 실력이 늘어 커피 맛은 제법 괜찮다. 아니, 적어도 못하는 바리스타가 내린 커피보다 우리의 커피가 훨씬 맛있다. 당연하지만 참여는 자유다. 바쁘면 일이 먼저다. 참여를 강요한 사람은 아무도 없었지만, 이 시간을 위해 재택근무를 하려다가도 사무실로 출근하는 사람도 생겼다.</p><h3>토끼굴에서 빠져나온, 고여있지 않은</h3><p>우리는 정말 별의별 이야기를 다 한다. 반려묘 자랑부터 시작해서 어제 본 영화나 드라마, 운동 이야기까지. 하지만 개발자들이 모여 할 수 있는 이야기 중에 개발 이야기보다 더 재미있는 게 있을까. 거의 대부분은 개발이야기를 한다. 가끔은 토론을 하다가 바로 몹프로그래밍으로 이어지기도 한다. 요즘 가장 인기 있는 이야기는 단연 LLM 활용법과 터미널 꾸미기에 대한 이야기다.</p><p>가끔은 보스를 통해 옛날 이야기도 듣는다. EJB와 DCOM처럼 유행했던 기술의 흥망성쇠, 웹 개발의 여명기, 더 멀리 플로피 디스크와 천공 카드의 시대까지. 예전에 같이 일했던 훌륭한 동료와 팀, 때로는 실패한 프로젝트의 이야기도 나눈다. 실제 경험에서 나온 이야기의 힘은 정말 강력하다. 과거에 비추어 현재의 우리 모습을 바라보게 되기 때문이다.</p><ul><li>복잡도를 낮추기 위해 도입한 것이 오히려 불필요한 복잡도를 유발하는 <a href="https://en.wikipedia.org/wiki/Object%E2%80%93relational_mapping">애물단지</a>가 되고 있지는 않은지?</li><li><a href="https://en.wikipedia.org/wiki/Down_the_rabbit_hole">토끼굴</a>에 빠져 아무도 공감하지 않는 과도한 추상화에 골몰하고 있는 것은 아닌지?</li><li>개인의 경력을 위한 <a href="https://en.wikipedia.org/wiki/Overengineering">오버엔지니어링</a>을 팀에서 방조하고 있지는 않은지?</li><li>일을 어떻게 나누고 어떤 순서로 해야 하는지?</li><li>개발자로서 어떤 윤리의식을 가져야 하는지?</li></ul><p>주니어 개발자는 시니어 개발자의 경험을 통해 같은 실수를 반복하지 않게 된다. 개발자들은 종종 바퀴뿐만 아니라 실수까지도 재발명하고 만다. 시니어 개발자는 주니어 개발자의 경험을 통해 과거의 자신을 떠올리고, 잊고 있었던 중요한 원칙들을 되새긴다.</p><p>우리는 그렇게 서로를 각자의 토끼굴에서 끄집어낸다. 그리고 비로소 한팀이 됐다. 언젠가 우리 모두 흩어져 서로 다른 길을 가게 되겠지만, 커피를 마시며 나눴던 이야기들은 오랫동안 기억에 남을 것 같다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba826ab079c2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[2023년 회고 — 두 세계 사이에서]]></title>
            <link>https://medium.com/@jazzbach/2023%EB%85%84-%ED%9A%8C%EA%B3%A0-%EB%91%90-%EC%84%B8%EA%B3%84-%EC%82%AC%EC%9D%B4%EC%97%90%EC%84%9C-fd96e89f2f7c?source=rss-fcc33dd70f8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/fd96e89f2f7c</guid>
            <category><![CDATA[회고]]></category>
            <category><![CDATA[개발자]]></category>
            <dc:creator><![CDATA[Kiwon Lee (이기원)]]></dc:creator>
            <pubDate>Sun, 31 Dec 2023 04:22:21 GMT</pubDate>
            <atom:updated>2023-12-31T04:38:04.341Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O6ej6BnyQj2PBhIpA11e-g.jpeg" /></figure><h3>2023년 회고 — 두 세계 사이에서</h3><p>케타포에 합류한 지도 이제 1년하고도 반이 지났다.</p><p>그동안의 개인적인 소회와 목표로 회고를 채웠다.</p><h3>리더와 IC(Individual Contributor) 사이</h3><p>우리 팀은 나를 포함해 12명으로, 적지 않은 인원이다. 팀장이 된 지 일 년이 넘었지만 그만하고 싶다는 생각이 들지 않는 걸 보니 그럭저럭 적성에 맞는 모양이다. 때론 코딩보다 동료들을 관찰하는 게 더 재미있다. 까마귀처럼 호기심이 많은 관계로, 남을 관찰하는 데 큰 노력을 기울일 필요가 없다. 관찰하다가 적절하게 개입한다. 다만 너무 일찍 개입해서 참견하지 않는다. 너무 빨리 의견을 말하지 않는다. 이런 점은 전 회사의 팀장님에게서 배웠다.</p><p>올해는 나와 비슷한 시기 회사에 합류한 시니어 개발자의 이직으로 시작했다. 기술적으로나 인격적으로 배울 점이 많은 선배 개발자였다. 무엇보다도 그분의 스타일을 좋아했다. 서비스 전면 장애가 난 상황에서도 “허허.. 이거 이상하네?”하고 웃을 수 있는 사람이었다. 차라리 나 말고 그분이 팀장을 맡았더라면 쉽게 이직 못 하셨을 텐데 하는 생각도 들었다. 그만큼 아쉬웠다.</p><p>이 시기 나는 꽤 흔들렸다. 마음 편히 일을 맡기기엔 아직 대다수 팀원의 숙련도가 낮았다. 개발자와 개발팀장은 달랐다. 팀 운영을 위해 자잘한 행정 업무를 포함해 신경 쓸 게 많고, 좀 집중하려고 하면 장애가 터지거나 CS가 들어오거나 했다. 정신이 없었다. 점점 회사 가는 것이 재미없어졌고, 퇴근할 때마다 어떻게 하면 나아질 수 있을지 생각했다.</p><p>팀에서 에이스라고 불리던 시절이 그리웠다. 한 줄도 코딩하지 못한 날이 많아졌다. 그런 날에는 집에 가서 혼자 리팩터링을 했다. 나는 내색하지 않았지만, 보스가 내 상태를 모를 리 없었다. 경험이 쌓이면 보고 싶지 않아도 보이는 것들이 있다. 사실 나도 동료의 눈빛을 보면 가끔 이렇게 말하고 싶을 때가 있다. “XX님 요즘 회사일이 재미없죠?”.</p><p>이때는 그냥 꾹 참고 시간이 지나가기를 기다렸다. 자잘하고 지저분한 운영 업무도 회사를 오래 다닌 동료의 도움을 받아 직접 했다. 위임을 잘했으면 더 쉬웠을 테지만, 회사에 합류한 지 얼마 안 되어 스스로 업무를 잘 모르는 상태에서 무작정 위임 할 순 없었다. 그건 위임이 아니라 방임일 것이다. 그렇게 몇 달이 흘렀다. 그동안 다행히도 시스템이 점차 안정을 찾았다. 어지간한 트래픽에는 장애가 나지 않게 되었다.</p><p>어느 정도 도메인을 알고 난 후에는 CS 업무를 주번을 정해 돌아가면서 하는 것으로 바꿨다. 2~30분 안에 스스로 해결 못하면 동료들에게 알려야 한다는 룰도 만들었다. 그리고 난 멘션 알림만 남기고 CS 채널의 알림을 꺼버렸다. 단지 이것만으로도 업무 스트레스가 극적으로 줄었다. 처음엔 주니어들이 스스로 해결할 수 있는 문제가 별로 없으니, 결국 일은 다시 내 몫이었다. CS 당번과 둘이, 또는 레거시 코드를 잘 아는 동료와 셋이 함께 문제를 해결하곤 했다.</p><p>사실 이때까지만 해도 상황이 이렇게 빨리 좋아질 줄은 몰랐다. 지금은 개인차가 있지만 팀원 대다수가 어느 정도 CS 업무를 할 수 있게 되었다. 습관적으로 하던 APM 리뷰도 정례화해서 월요일에 한 번씩 Datadog 지표와 로그를 리뷰하는 시간을 만들었다. 이런 것도 모여서 같이하면 몹/페어 프로그래밍과 비슷한 효과가 있다. 주니어들은 시스템의 문제를 찾아내는 방법을 배운다. 아니 그보다는 문제 해결을 위한 시야와 접근 방식을 체화한다. 이런 방식으로 눈부신 성장을 이룬 동료도 있고, 처음엔 눈에 띄지 않던 동료도 뒤돌아보면 어느새 많이 성장해 있다. 지난 일 년 사이 우리 팀은 더 강해졌다.</p><p>이런 과정이 있고 나서, 요즘엔 아쉬운 마음이 들지 않을 정도로 문제에 집중할 수 있게 되었다. 처음부터 끝까지 다 하기보다 개발 초기에 전반적인 컨셉트를 잡거나, 레거시 코드에 변경을 일으키기 쉽도록 리팩터링하는 일을 주로 한다. 나는 운이 좋다. 훌륭한 보스와 팀 동료들 덕분에 리더와 IC 두 가지 역할이 모두 재미있다. 동료들을 생각하면 언제나 감사한 마음 뿐이다.</p><h3>옳은 것과 되는 것 사이</h3><p>가능하면 늘 “옳은 것”을 하고 싶다. 개발자 입장에서 올바른 것은 변경하기 쉬운 코드와 아키텍처를 말한다. 하지만 올해에도 기술 부채를 쌓고 <a href="https://martinfowler.com/bliki/SacrificialArchitecture.html">희생적 아키텍처</a>를 택한 순간들이 종종 있었다. 때론 일단 되는 것이 중요할 때가 많다.</p><p>예를 들자면, 얼마 전 회사가 영업을 굉장히 잘해서 거의 공돈을 벌 기회를 만들어 냈다. 그런데 그 기회를 살리기 위해서는 레거시 주문/결제를 변경해야 했다. 그걸 “올바른 방식”으로 하려면, 아마 재개발밖에 없을 것이다. 주문 쪽 JSP/jQuery 코드는 툴로 리팩터링 할 수 없다. 사실상 걸레 쪼가리나 다름없는 상태이다.</p><p>이런 상황에서 옳은 것만 주장하기보다 현재 상황에서 되는 것과 안 되는 것을 설명하고, 타협점과 다른 팀의 도움을 끌어내는 것은 꽤 섬세하고도 재미있는 과정이다. 이런 부분을 글로 잘 묘사할 수 없어서 아쉽다. 좋은 선배 개발자를 만나 일하는 방식을 배우는 것이 가장 좋다. 중요한 것은 전문가로서 명확한 기준을 가지면서도, 다른 사람들의 어려움이나 도움의 필요성에 공감하는 것이다.</p><p>물론 이런 종류의 일은 기술적으로는 나에게 득 될 게 별로 없는 게 사실이다. 그래도 재미가 아주 없지는 않다. 변경 범위를 최대한 줄여서 버그와 기술 부채의 증가를 최소화한다. 그렇다고해도 2023년에 jQuery 디버깅을 밤새 붙잡고 있는 게 백엔드개발자 커리어에 무슨 도움이 될까. 이런 일은 가능하면 주니어 동료들에게 맡기지 않는다. 레거시 코드를 꽤 많이 다뤄 본 나도 하기 싫고 어려운 일을 동료에게 맡기기는 쉽지 않다. 언제 끝날지도 알 수 없고.</p><p>좁게 보면 손해인 것 같지만 넓게 보면 득이 크다. 작은 회사에서 “일이 되게 만드는 사람”이라는 평판을 얻는 것은 대단히 중요하다. 신뢰가 없으면 역설적으로 시키는 일만 하고 경주마처럼 앞만 보고 달려야 한다. 균형이 중요하다. 이것저것 따지지 않고 닥치는 대로 다 할 수 있다고 하면 지옥 같은 환경의 개발 조직이 될 것이다. 그런 상황은 자신을 포함해서 누구에게도 이롭지 않다.</p><p>상황에 따른 명확한 기준을 가지기 위해 노력한다. 한 걸음 물러서서 상황을 보는 것은 언제나 도움이 된다. 현재 되는 것과 안 되는 것이 무엇인가? 개발자가 할 수 있는 것과 할 수 없는 것이 무엇인가? 개발자가 할 수 없다면, 다른 조직의 사람들로부터 어떻게 도움을 끌어낼 수 있을까?</p><p>내년에는 옳은 것과 되는 것 사이에서 더 나은 결정을 내리고 싶다.</p><h3>OOP와 FP 사이</h3><p>레거시 코드 리팩터링을 좋아하지만, 가끔(아니 자주) 한숨이 나온다. 누군들 안 그럴까. 명령형(Imperative) 프로그래밍 스타일의 코드를 보면서 <a href="https://ko.wikipedia.org/wiki/%EC%95%85%EC%9D%98_%ED%8F%89%EB%B2%94%EC%84%B1#:~:text=%EC%95%85%EC%9D%98%20%ED%8F%89%EB%B2%94%EC%84%B1%EC%9D%B4%EB%9E%80%2C%20%EB%AA%A8%EB%93%A0,%EB%90%A0%20%EC%88%98%20%EC%9E%88%EB%8B%A4%EB%8A%94%20%EA%B0%9C%EB%85%90%EC%9D%B4%EB%8B%A4.">악의 평범성</a>을 생각한다. 명령형 스타일 자체는 죄가 없다고 생각한 적도 있지만, 악을 너무 쉽게 방조한다면 그 자체로 책임을 피할 수 없지 않나?</p><p>우리 팀에 React 프론트엔드 개발을 경험해 본 주니어 개발자가 있다. 나는 이분의 코드가 마음에 든다. 변수나 함수 이름을 잘 짓는다는 점이 가장 마음에 든다. 최소한 동사와 명사를 구별하고, 어순도 잘 맞춘다. 어쩌면 개발 초반에는 영어 실력이나 언어 감각이 가장 중요한지도 모르겠다. 그런데 그것보다 더 좋은 점은 Mutation에 대해 꽤 신중하게 접근한다는 점이다. 아마도 처음부터 React로 개발을 배웠으니, 간접적으로나마 FP의 세례를 받아서 그런 것이 아닐까.</p><p>명령형 스타일에만 익숙한 개발자들은 Mutation을 너무 쉽게 만드는 악을 범한다. 개발자로서 우리는 의식의 흐름보다 원칙을 따라야 한다. 클래스에 가변 필드 하나 더 만드는 것을 보증 서는 것처럼 조심스럽게 해야 한다. 특히 필드가 다른 필드와 <a href="https://engineering.linecorp.com/ko/blog/code-readability-vol3">직교인지 비직교인지</a> 늘 살펴야 한다.</p><p>객체지향 프로그래밍에는 그것만의 엘레강스가 있다. 잘 짠 객체지향 코드는 단지 상태가 A에서 B로 전이되는 것을 나타내는 것을 넘어, 코드를 읽는 사람으로 하여금 도메인을 체계적으로 이해할 수 있게 한다. 가끔 잘 짠 클래스를 보면 마음이 뛴다. 다만 그런 코드를 짜는 것은 장인 정신이 필요한, 평생의 과업이라는 점이 문제이다. 코드리뷰를 하면서 늘 하는 생각은 “그래서, 상태가 어떻게 변하는데?”라는 것이다. 캡슐화가 꽤 그럴 듯하게 되어 있다고 해도 객체 그래프 내부의 상태 변화를 추적하는 것은 인지 부하를 가중한다. 때론 <a href="https://en.wikipedia.org/wiki/Pure_function">더 단순한 방법</a>이 있는데 늘 한 가지만 고집해야 할까.</p><p>FP를 한다고 해서 <a href="https://en.wikipedia.org/wiki/Functor_(functional_programming)">Functor</a>니 <a href="https://en.wikipedia.org/wiki/Monad_(functional_programming)">Monad</a>니 처음부터 멀리 갈 필요없다고 생각한다. 단지 변수를 하나라도 더 불변으로 만드는 것이 다른 무엇보다도 가독성에 도움이 된다고 느낄 때가 많다. 우리 팀의 자바 코드 스타일은 기본으로 final 을 붙이는 것이다. 그러면 누군가 final을 때고 싶을 때 한 번 더 생각할 것이다. 모두의 실력이 일정 수준 이상이라면 이런 규칙이 필요 없다. 알아서 잘할 것이다.</p><p>최근엔 대가들조차도 FP를 강조한다. <a href="https://blog.ploeh.dk/">Mark Seemann</a>의 최근 포스트를 보면 F#으로 된 예제가 많다. 심지어 <a href="http://cleancoder.com/products">Robert C. Martin</a> 조차도 <a href="https://www.amazon.com/Functional-Design-Principles-Patterns-Practices/dp/0138176396">FP에 대한 책</a>을 냈으니 말 다한 것이다. 이제는 웹 백엔드개발자들도 FP에 대해 진지하게 공부해야 할 때가 아닌가 싶다.</p><p>내년의 목표는 <a href="https://www.amazon.com/Domain-Modeling-Made-Functional-Domain-Driven/dp/1680502549">FP 도메인 모델링</a>을 공부하고, 일정 복잡도를 넘는 시스템에 적절하게 <a href="https://learn.microsoft.com/en-us/azure/architecture/patterns/event-sourcing">Event Sourcing</a>을 적용해 보는 것이다. FP의 문제해결 접근 방식을 공부하면 OOP도 더 잘할 수 있으라라 믿는다.</p><h3>내향성과 외향성 사이</h3><p>내향성인 사람으로, 컨디션이 좋으면 하루에 최대 3시간까지 “외향성인 척” 할 수 있다. 진짜 외향성이 강한 사람들은 태양전지처럼 사람들과 만남으로서 충전된다고 한다. 그러나 나는 콘센트 충전식이라 집에서 충전이 필요하다. 평일에 퇴근하고 누굴 만나기 쉽지 않다. 사실은 “못난 놈”이라는 외향인들의 무자비한 낙인을 피할 정도로만 파사드를 유지하고 있다. 발뒤꿈치를 들고는 오래 못 서있는다고 노자가 말했다. 내면의 소리를 무시하고 반대로 살았을 때 언제나 대가를 치렀다. 몸이 아프거나 짜증을 내서 나뿐만 아니라 주변 사람들을 힘들게 하거나.</p><p>올해는 앞으로의 커리어를 위해 어떤 성장 모델을 선택해야 하는지 많이 생각했다. 평범한 외향인의 일상인, 일주일에 몇 번씩 술자리를 갖는 모델은 흉내 낼 수 없다. 다행히도 개발자는 내향인에게 나쁘지 않은 직업이다. 내향성이면서 뛰어난 리더는 분명 있다. 그러나 눈에 잘 띄지 않는다. 분명 나에게 맞는 전략을 찾을 수 있을 것이다.</p><p>술보다는 커피가 좋다. 우리 팀은 매일 아침 점심으로 30분씩 커피타임을 갖는다. 당연히 바쁘면 일을 한다. 참여는 자율이다. 먼저 온 사람이 드리퍼로 커피를 내린다. 원두는 비싸고 맛있는 원두일 때도 있고 아닐 때도 있다. 개발자들이 모여서 무슨 이야기를 할까? 개발 이야기는 아무리 해도 질리지 않는다. 소소한 일상 이야기도 한다. 주말에 갔던 맛집이라던가. 이런 걸 내부 개발자들뿐만 아니라, 외부인과도 자주 하고 싶다. 술보다 커피를 좋아하는 사람은 얼마든지 있을 것이다.</p><p>내향성인 리더가 좋은 점이 하나 있다. 누군가 회의 때 말을 더듬더라도, 갑작스러운 질문에 대답을 못하더라도, 점심을 늘 혼자하고 싶어 해도 괜찮다. 장담컨대 그런 것으로 쉽게 평가하거나 답답해하지 않을 것이다. 못하는 일보다 잘하는 일을 더 잘하게 해주고 싶다. 열심히 일하고도 눈에 띄지 않는다고 생각한다면, 업무 가시성을 더 높게 만드는 방법을 같이 고민하고 싶다.</p><p>마지막으로 새해의 가장 중요한 목표, 꾸준히 글을 쓰고 공개하는 것이다. 빨리 쓰거나 많이 쓰지 못해도 상관없다. 생각을 정리하는 것 — 글쓰기의 일차적인 목표만 이룬다는 마음으로.</p><h3>요약</h3><ul><li>어려운 순간들을 버텨내며 팀 리더 역할을 해냈고(아직 “잘”은 아니지만), 동료들과 함께 성장했다.</li><li>옳은 것과 되는 것 사이에서 고민할 때가 많았고, 내년에는 더 나은 결정을 내리고 싶다.</li><li>내년엔 함수형 프로그래밍에 대해 깊이있게 공부하고, 더 나은 코드로 한 발 더 나아가고 싶다.</li><li>나에게 맞는 성장 모델을 찾는 것에 집중하고, 꾸준한 글쓰기를 통해 생각을 정리한다.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fd96e89f2f7c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>