<div id="readability-page-1" class="page"><article><div><blockquote>이 글은 2024년 6월 13일에 일본어로 먼저 발행된 기사를 번역한 글입니다.</blockquote>
<p>LY Corporation은 높은 개발 생산성을 유지하기 위해 코드 품질 및 개발 문화 개선에 힘쓰고 있습니다. 이를 위해 다양한 노력을 하고 있는데요. 그중 하나가 Review Committee 활동입니다.</p>
<p>Review Committee에서는 머지된 코드를 다시 리뷰해 리뷰어와 작성자에게 피드백을 주고, 리뷰하면서 얻은 지식과 인사이트를 Weekly Report라는 이름으로 매주 공유하고 있습니다. <span>이 Weekly Report 중 일반적으로 널리 적용할 수 있는 주제를 골라 블로그에 <a href="https://techblog.lycorp.co.jp/ko/techniques-for-improving-code-quality-list" target="_blank">코드 품질 개선 기법 시리즈</a>를 연재하고 있습니다.</span></p>
<p><span>이번에 블로그로 공유할 Weekly Report의 제목은 '고르디우스 변수'입니다(참고: <a href="https://ko.wikipedia.org/wiki/%EA%B3%A0%EB%A5%B4%EB%94%94%EC%9A%B0%EC%8A%A4%EC%9D%98_%EB%A7%A4%EB%93%AD" target="_blank">고르디우스의 매듭</a>).</span></p>
<h2 id="고르디우스-변수">고르디우스 변수</h2>
<p>로컬과 원격, 두 저장소에 <code>FooData</code>라는 데이터가 저장돼 있고 이를 동기화하기 위해 <code>FooSynchronizer</code>를 구현한다고 가정해 보겠습니다. 여기서 가정&nbsp;상황은 다음과 같습니다.</p>
<ul><li>원격 <code>FooData</code>가 원본이고, 이를 사용해 로컬 <code>FooData</code>를 업데이트한다.</li><li>원격 및 로컬 데이터는 각각 <code>FooLocalDao</code>와 <code>FooRemoteClient</code>에서 가져올 수 있다.</li><li>문제를 단순화하기 위해 트랜잭션 등은 고려하지 않아도 된다.</li></ul>
<p><code>FooSynchronizer</code>의 <code>synchronizeWithRemoteEntries</code> 함수에서는 로컬과 원격 간 <code>FooData</code> ID 목록을 비교하고, 그 결과에 따라 추가, 업데이트, 삭제를 수행합니다.</p>
<ul><li>추가: ID가 원격에만 존재할 때 실행(<code>id !in localEntryIds &amp;&amp; id in remoteEntryIds</code>가 <code>true</code>일 때 실행)</li><li>업데이트: ID가 로컬과 원격에 모두 존재할 때 실행(<code>id in localEntryIds &amp;&amp; id in remoteEntryIds</code>가 <code>true</code>일 때 실행)</li><li>삭제: ID가 로컬에만 존재할 때 실행(<code>id in localEntryIds &amp;&amp; id !in remoteEntryIds</code>가 <code>true</code>일 때 실행)</li></ul>
<p>이 사양을 충족하도록 다음과 같이 <code>FooSynchronizer</code>를 구현했습니다.</p>
<pre><code>class FooSynchronizer(
    private val fooRemoteClient: FooRemoteClient,
    private val fooLocalDao: FooLocalDao
) {
    fun synchronizeWithRemoteEntries() {
        val remoteEntries: List&lt;FooModel&gt; = fooRemoteClient.fetch()
        val remoteEntryIds = remoteEntries.map(FooModel::id).toSet()

        val localEntries: List&lt;FooModel&gt; = fooLocalDao.getAllEntries()
        val localEntryMap = localEntries.associateBy(FooModel::id)
        val localEntryIds = localEntryMap.keys

        val createdEntryIds = remoteEntryIds.subtract(localEntryIds)
        val deletedEntryIds = localEntryIds.subtract(remoteEntryIds)

        remoteEntries.forEach { remoteEntry -&gt;
            // 항목 추가
            if (remoteEntry.id in createdEntryIds) {
                ... // `remoteEntry`를 사용해 '추가'하는 로직
                return@forEach
            }

            // 항목 업데이트
            val localEntry = localEntryMap[remoteEntry.id]
                ?: error("This must not happen.")
            ... // `remoteEntry`와 `localEntry`를 사용해 '업데이트'하는 로직
        }

        localEntries.asSequence()
            .filter { it.id in deletedEntryIds }
            .forEach { deletedEntry -&gt;
                ... // `deletedEntry`를 사용해 '삭제'하는 로직
            }
    }
}</code></pre>
<p>여기서 <code>List.associateBy</code>는 <code>List</code>에서 <code>Map</code>을 생성하는 함수입니다. 즉 <code>localEntries.associateBy(FooModel::id)</code>는 ID를 키로, <code>FooData</code>를 값으로 하는 <code>Map</code>을 반환합니다. 또한 <code>subtract</code>는 집합의 차집합(수신자에 포함되고 인수에는 포함되지 않는 요소)을 반환하는 함수입니다.</p>
<p>이 코드에서 개선할 수 있는 점이 있을까요?</p>
<h3 id="매듭을-풀기-위한-중간-목표">매듭을 풀기 위한 중간 목표</h3>
<p>이 코드의 흐름을 따라가려면 상당한 노력이 필요합니다. 그 이유 중 하나는<strong> </strong>데이터의 의존성이 복잡하게 얽혀 있기 때문입니다. 예를 들어 추가할 요소 목록인 <code>createdEntryIds</code>를 구하는 흐름은 다음과 같습니다.</p>
<ul><li><code>remoteEntries</code>에서 <code>remoteEntryIds</code>를 구한다.</li><li><code>localEntries</code>에서 <code>localEntryMap</code>를 구하고 거기서 다시 <code>localEntryIds</code>를 구한다.</li><li><code>remoteEntryIds</code>와 <code>localEntryIds</code>를 비교해서 <code>createdEntryIds</code>를 구한다.</li></ul>
<p>또한 <code>createdEntryIds</code>는 ID만 가지고 있으므로 실제로 추가를 수행하려면 <code>FooData</code>를 가져와야 하며, 이에 따라 위 코드에서는 <code>remoteEntries</code>를 다시 사용하고 있습니다. 이처럼 동일한 데이터를 여러 번 사용하면 처리 흐름이 복잡해집니다.</p>
<p>여기에 업데이트와 삭제 코드 관련해서도 복잡한 의존성 때문에 발생하는 문제가 있습니다.</p>
<ul><li>업데이트 코드 문제: <code>localEntryMap</code>에 대한 의존성 때문에 원래라면 발생할 수 없는 런타임 에러를 정의해야 한다.</li><li>삭제 코드 문제: 추가 및 업데이트 코드와 일관성이 맞지 않는다.</li></ul>
<p>위와 같은 문제를 해결하려고 할 때,<strong>&nbsp;</strong>이상적인 중간 데이터가 어떤 것인지 상상하고 거기서부터 함수의 구성을 역으로 설계하면 잘 풀릴 때가 있습니다. 이번 경우에는 데이터 추가, 업데이트, 삭제를 수행하므로 <code>createdEntries</code>, <code>updatedEntries</code>, <code>deletedEntries</code>라는 세 쌍이 있다면 코드를 단순화할 수 있을 것입니다.</p>
<p>이 세 쌍은 다음과 같이 만들 수 있습니다.</p>
<ol><li>로컬과 원격의 모든 ID 집합 <code>allEntryIds</code>를 생성한다.</li><li>각 ID에 대해 로컬 및 원격 데이터 쌍 <code>Pair&lt;FooData?, FooData?&gt;</code>를 생성한다.</li><li><code>Sequence&lt;Pair&lt;S?, T?&gt;&gt;</code>에서 세 쌍을 만드는 <code>partitionByNullity</code> 함수를 만든다. 세 쌍의 각 요소는 다음과 같다.
<ul><li>첫 번째 요소 <code>List&lt;S&gt;</code>: <code>S</code>가 non-null이고 <code>T</code>가 null인 경우</li><li>두 번째 요소 <code>List&lt;Pair&lt;S, T&gt;&gt;</code>: <code>S</code>와 <code>T</code>가 모두 non-null인 경우</li><li>세 번째 요소 <code>List&lt;T&gt;</code>: <code>S</code>가 null이고 <code>T</code>가 non-null인 경우</li></ul>
</li></ol>
<p>위에서 생성한 <code>partitionByNullity</code>를 사용하면 함수 흐름을 간결하게 만들 수 있습니다. 대략적인 흐름은 다음과 같습니다.</p>
<ol><li>ID -&gt; 원격 <code>FooData</code>의 <code>Map</code>, <code>remoteEntryMap</code>을 생성한다.</li><li>ID -&gt; 로컬 <code>FooData</code>의 <code>Map</code>, <code>localEntryMap</code>을 생성한다.</li><li><code>remoteEntryMap</code>과 <code>localEntryMap</code>에서 추가, 업데이트, 삭제 항목 <code>(createdEntries, updatedEntries, deletedEntries)</code>을 생성한다.</li><li><code>createdEntries</code>, <code>updatedEntries</code>, <code>deletedEntries</code> 각각에 대해 추가, 업데이트, 삭제를 실행한다.</li></ol>
<p>구현 예시는 다음과 같습니다.</p>
<pre><code>    fun synchronizeWithRemoteEntries() {
        val remoteEntries: List&lt;FooModel&gt; = fooRemoteClient.fetch()
        val remoteEntryMap = remoteEntries.associateBy(FooModel::id)

        val localEntries: List&lt;FooModel&gt; = fooLocalDao.getAllEntries()
        val localEntryMap = localEntries.associateBy(FooModel::id)
        
        val allEntryIds = remoteEntryMap.keys + localEntryMap.keys
        val (createdEntries, updatedEntries, deletedEntries) = allEntryIds.asSequence()
            .map { id -&gt; remoteEntryMap[id] to localEntryMap[id] }
            .partitionByNullity()
        
        createdEntries.forEach { createdEntry -&gt;
            ... // `createdEntry`를 사용해 '추가'하는 로직
        }

        updatedEntries.forEach { (remoteEntry, localEntry) -&gt;
            ... // `remoteEntry`와 `localEntry`를 사용해 '업데이트'하는 로직
        }
        
        deletedEntries.forEach { deletedEntry -&gt;
            ... // `deletedEntry`를 사용해 '삭제'하는 로직
        }
    }

    companion object {
        /** ... */
        private fun &lt;S : Any, T : Any&gt; Sequence&lt;Pair&lt;S?, T?&gt;&gt;.partitionByNullity():
                Triple&lt;List&lt;S&gt;, List&lt;Pair&lt;S, T&gt;&gt;, List&lt;T&gt;&gt; {
            val leftEntries: MutableList&lt;S&gt; = mutableListOf()
            val bothEntries: MutableList&lt;Pair&lt;S, T&gt;&gt; = mutableListOf()
            val rightEntries: MutableList&lt;T&gt; = mutableListOf()
            forEach { (left, right) -&gt;
                when {
                    left != null &amp;&amp; right == null -&gt; leftEntries += left
                    left != null &amp;&amp; right != null -&gt; bothEntries += left to right
                    left == null &amp;&amp; right != null -&gt; rightEntries += right
                    else /* left == null &amp;&amp; right == null */ -&gt; Unit
                }
            }
            return Triple(leftEntries, bothEntries, rightEntries)
        }
    }</code></pre>
<p>이렇게 하면 <code>synchronizeWithRemoteEntries</code> 내에서 가장 중요한 코드인 추가, 업데이트, 삭제의 <code>forEach</code>를 부각할 수 있습니다.</p>
<hr>
<blockquote>
<p>한 줄 요약: 데이터의 의존성이 복잡할 때는 이상적인 중간 데이터를 생성해서 정리할 수 있다.</p>
<p>키워드: <code>data dependency</code>, <code>function flow</code>, <code>intermediate data structure</code></p>
</blockquote></div></article></div>

LINE ENGINEERING

이 글은 2024년 6월 13일에 일본어로 먼저 발행된 기사를 번역한 글입니다.LY Corporation은 높은 개발 생산성을 유지하기 위해 코드 품질 및 개발 문화 개선에 힘쓰고...

코드 품질 개선 기법 29편: 고르디우스 변수

댓글