<?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 kyuchulkim on Medium]]></title>
        <description><![CDATA[Stories by kyuchulkim on Medium]]></description>
        <link>https://medium.com/@kyuchul2?source=rss-46a4ba84478------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*C9reBGn1CETS-CXIZVbiiw.jpeg</url>
            <title>Stories by kyuchulkim on Medium</title>
            <link>https://medium.com/@kyuchul2?source=rss-46a4ba84478------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 10:56:08 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kyuchul2/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[[iOS] Liquid Glass TabBar의 prominent 대응]]></title>
            <link>https://medium.com/@kyuchul2/ios-liquid-glass-tabbar%EC%9D%98-prominent-%EB%8C%80%EC%9D%91-ios27-26-%EB%B6%84%EA%B8%B0-8f88281b1e4e?source=rss-46a4ba84478------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f88281b1e4e</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[liquid-glass]]></category>
            <category><![CDATA[uikit]]></category>
            <category><![CDATA[swiftui]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[kyuchulkim]]></dc:creator>
            <pubDate>Thu, 17 Sep 2026 04:59:19 GMT</pubDate>
            <atom:updated>2026-09-17T05:00:41.419Z</atom:updated>
            <content:encoded><![CDATA[<h4>iOS27 &amp; 26 Liquid Glass TabBar 분기 처리</h4><h3><strong>들어가며</strong></h3><p><a href="https://medium.com/@kyuchul2/ios-view-snapshot-%EA%B5%90%EC%B2%B4-%EB%B0%A9%EC%8B%9D%EC%9D%84-%ED%99%9C%EC%9A%A9%ED%95%9C-%ED%83%AD-%EC%A0%84%ED%99%98-%EC%8B%9C-%EC%9D%B4%EC%A0%84-%ED%99%94%EB%A9%B4-%EC%9C%A0%EC%A7%80-%ED%8A%B8%EB%A6%AD-8ea52b0d45d1">지난 글</a>에서는 Liquid Glass TabBar의 우측 분리된 원형 버튼을 따라 만들면서, `UISearchTab`을 빌려 쓰고 빈 placeholder가 노출되는 문제를 snapshot 교체로 가렸습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*AhpPNoEcnu_6mVLj.png" /></figure><p>iOS 27에서 이 부분에 정식 API가 생겼습니다. 이번 글에서는 27에서 무엇이 추가되었고, 그럼에도 26 이하에서는 왜 여전히 기존 방식을 유지해야 하는지를 실제로 빌드해서 확인한 내용으로 정리해 보려고 합니다.</p><h3>iOS 27에 추가된 prominentTabIdentifier</h3><p>`UITabBarController.h`에 다음 프로퍼티가 추가되었습니다.</p><pre>@property (nonatomic, copy, nullable) NSString *prominentTabIdentifier<br> API_AVAILABLE(ios(27.0), visionos(27.0)) API_UNAVAILABLE(tvos, watchos);<br>- (void)setProminentTabIdentifier:(nullable NSString *)identifier animated:(BOOL)animated<br> API_AVAILABLE(ios(27.0), visionos(27.0)) API_UNAVAILABLE(tvos, watchos);</pre><ul><li>UITab을 식별자로 지목하면 그 탭이 분리된 원형 버튼으로 승격됩니다</li><li>- <a href="https://developer.apple.com/documentation/uikit/uitabbarcontroller/setprominenttabidentifier(_:animated:)">setProminentTabIdentifier(_:animated:)</a>로 런타임에 승격 대상을 바꾸는 것도 가능합니다</li></ul><blockquote>If this property is nil, and there is a `UISearchTab` that could become prominent, then the search tab will receive the prominent treatment by default.</blockquote><h3>SwiftUI/UIKit iOS 27, 26에서 분기 대응</h3><pre>// SwiftUI / iOS 27<br>Tab(role: .prominent) { ChatbotView() } label: { Label(&quot;AI&quot;, systemImage: &quot;sparkle&quot;) }<br><br>// SwiftUI / iOS 26<br>Tab(&quot;AI&quot;, systemImage: &quot;sparkle&quot;, role: .search) { ChatbotView() }<br><br>// UIKit / iOS 27<br>tbc.tabs = mainTabs + [chatbotTab]<br>tbc.prominentTabIdentifier = &quot;chatbot&quot;<br><br>// UIKit / iOS 26<br>let chatbot = UISearchTab { _ in ChatbotViewController() }<br>chatbot.image = icon<br>tbc.tabs = mainTabs + [chatbot]</pre><ul><li>SwiftUI에는 iOS 27 신규 `<a href="https://developer.apple.com/documentation/swiftui/tabrole/prominent">TabRole.prominent</a>`</li><li>UIKit에는 iOS 27 신규 `<a href="https://developer.apple.com/documentation/uikit/uitabbarcontroller/prominenttabidentifier">prominentTabIdentifier</a>`</li><li>26은 양쪽 모두 검색 역할을 빌려 쓰는 것 외에 선택지가 없습니다. <strong>(search를 기본적으로 쓰면서 아이콘은 커스텀으로 설정)</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/368/1*rMVI230xkDqNK_1CEk5SJQ.jpeg" /><figcaption>iOS27에서 prominentTabIdentifier를 쓴 모습</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/368/1*DEUolarb4_-fatzyabojzw.jpeg" /><figcaption>iOS26에서 UISearchTab를 쓴 모습</figcaption></figure><h3>VoiceOver 이슈</h3><pre>iOS 26: Tab(&quot;AI&quot;, systemImage: &quot;sparkle&quot;, role: .search) { ChatbotView() }<br>iOS 27: Tab(role: .prominent) { ChatbotView() } label: { Label(&quot;AI&quot;, systemImage: &quot;sparkle&quot;) }</pre><ul><li>26에선 role: .search를 편법으로 쓰고 있기 때문에 title을 무시하고 시스템이 “Search”를 붙입니다. 27로 올라가야 비로소 이 불일치가 해소됩니다.</li></ul><h3>마치며</h3><p>버전별로 정리하면 이렇습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xnSTMXZi3Dy9Wvt0z5NPRw.png" /></figure><h4>참고 자료</h4><ul><li>[UITabBarController.prominentTabIdentifier](<a href="https://developer.apple.com/documentation/uikit/uitabbarcontroller/prominenttabidentifier">https://developer.apple.com/documentation/uikit/uitabbarcontroller/prominenttabidentifier</a></li><li>[UITabBarController.setProminentTabIdentifier(_:animated:)](<a href="https://developer.apple.com/documentation/uikit/uitabbarcontroller/setprominenttabidentifier(_:animated:))">https://developer.apple.com/documentation/uikit/uitabbarcontroller/setprominenttabidentifier(_:animated:))</a></li><li>[UITabBarController.performBatchUpdates(_:)](<a href="https://developer.apple.com/documentation/uikit/uitabbarcontroller/performbatchupdates(_:))">https://developer.apple.com/documentation/uikit/uitabbarcontroller/performbatchupdates(_:))</a></li><li>[TabRole.prominent](<a href="https://developer.apple.com/documentation/swiftui/tabrole/prominent">https://developer.apple.com/documentation/swiftui/tabrole/prominent</a>)</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f88281b1e4e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[iOS] View Snapshot 교체 방식을 활용한 탭 전환 시 이전 화면 유지 트릭]]></title>
            <link>https://medium.com/@kyuchul2/ios-view-snapshot-%EA%B5%90%EC%B2%B4-%EB%B0%A9%EC%8B%9D%EC%9D%84-%ED%99%9C%EC%9A%A9%ED%95%9C-%ED%83%AD-%EC%A0%84%ED%99%98-%EC%8B%9C-%EC%9D%B4%EC%A0%84-%ED%99%94%EB%A9%B4-%EC%9C%A0%EC%A7%80-%ED%8A%B8%EB%A6%AD-8ea52b0d45d1?source=rss-46a4ba84478------2</link>
            <guid isPermaLink="false">https://medium.com/p/8ea52b0d45d1</guid>
            <category><![CDATA[liquid-glass]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[uikit]]></category>
            <category><![CDATA[swiftui]]></category>
            <dc:creator><![CDATA[kyuchulkim]]></dc:creator>
            <pubDate>Fri, 15 May 2026 06:42:59 GMT</pubDate>
            <atom:updated>2026-05-19T01:14:45.009Z</atom:updated>
            <content:encoded><![CDATA[<h4>카카오뱅크 Liquid Glass TabBar의 챗봇 탭 동작 방식 구현해보기</h4><h3>들어가며</h3><p>안녕하세요, 이번 글에선 Liquid Glass 대응을 하며 iOS TabBar에서 탭을 전환해도 이전 화면이 그대로 보이게 하는 트릭을 고민하고 풀어본 저만의 방식을 이야기해 보려고 합니다.</p><h4>Liquid Glass TabBar 대응</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uzMFME4Rr9NiNmkWsminEQ.png" /><figcaption>검색 탭의 경우 본 탭바와 분리</figcaption></figure><p>회사의 앱 리뉴얼 작업을 진행하며 탭바를 Liquid Glass 구조로 변경하는 작업을 하게 되었습니다. 그중 기획팀에서 원하는 건 Liquid Glass가 적용된 앱들에서 종종 보이는 <strong>가장 오른쪽 탭이 본 탭바와 분리되어 있는 형태</strong>였습니다.</p><p>해당 탭을 누르면 기존 화면이 유지된 상태에서 신규 화면이 풀스크린 커버로 올라오는 동작을 원했고, 가장 흡사한 동작을 레퍼런스로 참고 할 수 있었던 서비스는 카카오뱅크의 iOS 앱 이였습니다.</p><h4>iOS 26 기준 Liquid Glass 분리 탭 구현 방법</h4><p>들어가기 앞서 Liquid Glass 우측 분리 탭 자체는 iOS 26 기준으로 Apple 공식 지원 API인 Search 기능을 우회하여 만들 수 있습니다.</p><pre>TabView(selection: $selectedTab) {<br>      Tab(&quot;홈&quot;, systemImage: &quot;house&quot;, value: .home) {<br>          HomeView()<br>      }<br>      // ... 나머지 메인 탭<br><br>      Tab(value: .search, role: .search) {<br>          SearchView()<br>      }<br>  }</pre><ul><li>SwiftUI에선 <strong>role: .search</strong>로 지정된 탭이 자동으로 우측에 분리된 형태로 렌더링 됩니다.</li></ul><pre>let tbc = UITabBarController()<br>  tbc.tabs = [<br>      UITab(title: &quot;홈&quot;, image: UIImage(systemName: &quot;house&quot;), identifier: &quot;home&quot;) { _ in<br>          UIHostingController(rootView: HomeView())<br>      },<br>      // ... 나머지 메인 탭<br><br>      UISearchTab { _ in<br>          SearchViewController()<br>      }<br>  ]</pre><ul><li>UIKit에선 iOS 18부터 추가된 <strong>UISearchTab</strong>을 사용해 iOS 26 환경에서 빌드하면 자동으로 우측 구조로 렌더링 됩니다.</li></ul><h3>카카오뱅크의 TabBar 전환 방식 살펴보기</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*QnhLOkbB0Kp403pvkj401A.gif" /><figcaption>챗봇 탭으로 전환 한 듯 보이지만 화면은 아직 이전 탭</figcaption></figure><p>살펴볼 방식은 카카오뱅크 2.60.0 버전 기준의 가장 우측의 챗봇 탭 전환 방식 입니다.</p><p>홈 탭(혹은 다른 메인 탭)에 있는 상태에서 챗봇 탭을 눌러보면 다음과 같은 흐름이 일어납니다.</p><ol><li><strong>현재 탭(예: 홈)의 selected 상태가 풀리고, 챗봇 탭으로 selected가 이동 (</strong>시각적으로 탭 selection 자체는 정상적으로 챗봇 탭으로 넘어감)</li><li><strong>하지만 화면은 여전히 직전 탭(홈)의 콘텐츠가 그대로 보임 (</strong>챗봇 탭의 빈 화면이 보이는 게 아니라, 직전에 보던 홈 화면이 그대로 남아 있음)</li><li>챗봇 탭을 누른 즉시 로딩 딤(dim)이 깔림</li><li>잠시 후 풀스크린 커버로 챗봇 대화 화면이 올라옴</li></ol><p>탭이 실제로 선택되기 직전에 전환 자체를 막고, 그 자리에서 Sheet를 띄우는 방식으로 쉽게 풀 수 있을 것 같았습니다. 그러나 다음과 같은 차이가 있었습니다.</p><ul><li>탭 selection은 실제로 챗봇 탭으로 이동합니다<strong>(Liquid Glass 탭 전환 애니메이션 확인, selected 표시가 진짜 챗봇 탭으로 넘어감)</strong> → <strong>즉 탭 전환은 실제로 발생했음</strong></li><li><strong>화면은 여전히 이전 탭(홈)의 콘텐츠를 보여줌</strong></li></ul><h3>첫번째 고민 방식: SwiftUI Binding setter</h3><p>프로젝트는 100% SwiftUI에 자체 커스텀 탭바를 쓰고 있었습니다. Liquid Glass 대응을 위해선 Apple 공식 TabView API로 마이그레이션 해야 했습니다.</p><h4>Binding setter에서 가로채기</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/295/1*wPCkgEDgruI7WSsQkWvuvA.gif" /><figcaption>투자 탭 -&gt; 챗봇 탭 이동 시 투자 탭이 깜박임</figcaption></figure><pre>var selectionBinding: Binding&lt;Tab&gt; {<br>      Binding(<br>          get: { self.selected },<br>          set: { newValue in<br>              if newValue == .chatbot {<br>                  self.triggerChatbotSheet() // selected는 그대로 두고 시트만 띄움<br>                  return<br>              } else {<br>                  self.selected = newValue<br>              }<br>          }</pre><ul><li>TabView의 selection 효과는 binding과 별개로 SwiftUI가 직접 처리 되는 문제가 있었습니다. setter에서 위 예시 처럼 selected 업데이트를 거부해도, 탭바의 selected 표시는 이미 한 프레임 챗봇 탭 쪽으로 갔다가 다시 홈으로 돌아옵니다.</li><li>더불어 이 방식은 실제로 탭 이동을 막기 때문에 <strong>selection은 실제로 쳇봇탭으로 이동되면서, 콘텐츠는 이전 탭 그대로 유지되는 방식의 구현</strong>이 불가했습니다.</li></ul><p>그렇기에 탭이 실제로 선택되기 전 시점을 알 수 있는 UIKit <strong><em>UITabBarControllerDelegate의 shouldSelectTab</em></strong> 사용이 필요하다고 판단했습니다.</p><h3>두번째 고민 방식: UIKit shouldSelectTab으로 가로채기</h3><pre>func tabBarController(<br>      _ tabBarController: UITabBarController,<br>      shouldSelect viewController: UIViewController<br>  ) -&gt; Bool {<br>      guard let index = viewControllers?.firstIndex(of: viewController),<br>            isChatbotTab(index)<br>      else { return true }<br><br>      showLoadingAndSheet()<br>      return false<br>  }</pre><ul><li>shouldSelectTab에서 챗봇 탭을 잡아 시트는 띄울 수 있었지만, return false기 때문에 전환 자체가 일어나지 않아 Liquid Glass 탭 전환 애니메이션이 재생되지 않았습니다. (tabBar.selectedItem이 안불림)</li></ul><p>Apple 공식 API TabBar의 탭 전환 애니메이션을 막을 순 없기에, 실제로 탭 전환 → 이전화면이 유지 → 그위에 시트가 띄워짐에 대한 고민만 남게 되었습니다.</p><h3>Timeline 애니메이션을 보고 떠오른 스냅샷 트릭</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*cY_ofXMTjrqxZ2uPYJuwJg.gif" /><figcaption><strong>최상단 투자/발견 탭 바로 아래 환율 관련 타임라인 컴포넌트</strong></figcaption></figure><p>카카오뱅크 투자 탭 상단에 <strong>환율 정보가 Timeline처럼 계속 흐르는 애니메이션</strong>이 있는 화면이 있었습니다.</p><p>투자 탭에서 챗봇 탭을 누른 순간 사진 한 장이 캡처된 것처럼 환율 정보 Timeline 애니메이션이 멈췄습니다. 그리고 챗봇 시트를 dismiss하고 돌아오니 애니메이션은 한참 흘러 있는 걸 체크할 수 있었습니다. <strong>(GIF의 달러 환율 USD 아이템 확인)</strong></p><p>즉, 챗봇 탭 진입은 실제로 이루어진 것이며, <strong>그 순간 이전 탭의 Snapshot 한 장을 챗봇 탭 화면에 띄워두면 어떨까 하는 방법</strong>을 생각해내게 되었습니다.</p><h3>View Snapshot 교체 방식을 활용한 탭 전환 시 이전 화면 유지 트릭 만들기</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/962/1*6YQp3hzD38yBvYgBiiQGrw.png" /></figure><p>selection은 실제로 챗봇 탭으로 이동시키되, <strong>챗봇 탭 View 위에 이전 탭의 Snapshot을 attach해 콘텐츠가 그대로 유지되는 것처럼 보이게</strong> 만들도록 구현 했습니다.</p><p><strong>1. shouldSelectTab에서 스냅샷 캡처 후 return true</strong></p><pre>func tabBarController(_ tbc: UITabBarController, shouldSelectTab tab: UITab) -&gt; Bool {<br>      guard tab is UISearchTab else { return true }<br><br>      // 1. 이전 탭 view의 스냅샷 캡처<br>      viewModel.capturedSnapshot = tbc.selectedViewController?.view.snapshotView(afterScreenUpdates: true)<br><br>      // 2. 이전 selectedIndex 기억 (시트 닫힘 시 복원용)<br>      previousSelectedIndex = tbc.selectedIndex<br><br>      // 3. 로딩 딤 → 450ms 후 시트<br>      isLoadingPresented = true<br>      <br>      Task { @MainActor [weak self] in<br>          try? await Task.sleep(for: ..)<br>          // 4. 시트 Open<br>          self?.isChatbotSheetPresented = true<br>      }<br><br>      return true   // 탭 전환 정상 진행 → Liquid Glass 탭 전환 애니메이션 정상 작동<br>  }</pre><ul><li><strong>snapshotView(afterScreenUpdates:)</strong>는 호출 시점의 view를 그대로 복사한 정지 UIView를 반환합니다. (<a href="https://developer.apple.com/documentation/uikit/uiview/snapshotview(afterscreenupdates:)">Apple 공식 문서</a>)</li><li>이 메서드를 활용해 직전 탭의 view를 한 장 떠놓고, 챗봇 탭으로 전환된 뒤 챗봇 VC에 이 SnapshotView를 붙이는게 핵심 아이디어 입니다.</li></ul><p>2. <strong>ChatBot 탭 PlaceholderVC에서 스냅샷 attach / detach</strong></p><pre>final class SearchPlaceholderViewController: UIViewController {<br>     override func viewWillAppear(_ animated: Bool) {<br>          super.viewWillAppear(animated)<br>          <br>          guard let snapshot = viewModel?.capturedSnapshot else { return }<br>					<br>	  // attach: 챗봇 탭 view에 스냅샷 꽉 채워 부착<br>          snapshot.frame = view.bounds<br>          snapshot.autoresizingMask = [.flexibleWidth, .flexibleHeight]<br>          view.addSubview(snapshot)<br>      }<br><br>      override func viewDidDisappear(_ animated: Bool) {<br>          super.viewDidDisappear(animated)<br>          // detach: view 완전 사라진 후 안전 제거<br>          viewModel?.capturedSnapshot?.removeFromSuperview()<br>      }<br>  }</pre><ul><li>viewWillAppear 시점에 스냅샷을 attach 해서 챗봇 탭의 빈 placeholder가 노출되지 않게 하고, 매 진입마다 갱신된 스냅샷이 보장되도록 했습니다.</li><li>제거는 viewDidDisappear에서 진행 했는데, viewWillDisappear는 transition 직전이라 빈화면 노출 위험으로 제외 했습니다.</li></ul><p>3. <strong>시트 닫힘 → selectedIndex 복원</strong></p><pre>func updateUIViewController(_ tbc: UITabBarController, context: Context) {<br>      // 시트가 닫힌 순간에만 복원<br>      guard viewModel.capturedSnapshot != nil,<br>            !viewModel.isLoadingPresented,<br>            !viewModel.isChatbotSheetPresented<br>      else { return }<br><br>      tbc.selectedIndex = context.coordinator.previousSelectedIndex<br>  }</pre><ul><li>SwiftUI에서 UITabBarController를 사용하기 위해 UIViewControllerRepresentable로 감싼 상태에서 시트 닫힘 같은 외부 상태 변화는 updateUIViewController에서 처리했습니다.</li><li>챗봇 시트를 닫으면 selectedIndex를 이전 탭으로 복원하고, 이 순간 placeholder VC의 viewDidDisappear에서 스냅샷이 detach됩니다.</li></ul><h4>Snapshot 방식 구현 동작</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/295/1*SsKo3s9_olR49CcN9ULl2g.gif" /><figcaption>챗봇 탭을 누른 순간 이전 투자 탭이 Snapshot</figcaption></figure><ul><li>챗봇 탭 진입 시 탭은 실제로 전환되었지만, 스냅샷을 통해 챗봇 VC가 이전 화면처럼 보이도록 구현되었습니다.</li><li>탭이 실제로 전환 되었기에 Liquid Glass 탭 전환 애니메이션은 정상 재생되고, 콘텐츠는 이전 탭 그대로 유지되어 카카오뱅크 iOS 앱의 동작과 동일한 결과를 얻었습니다.</li></ul><p>여기서 추가로 알게된 점은 로딩뷰의 숨은 역할 입니다.</p><ul><li>참고한 카카오뱅크의 경우 챗봇 탭 즉시 시트를 띄우지 않고 먼저 로딩 딤으로 화면을 막습니다.</li><li>시트가 뜨기 직전 그 짧은 순간 사용자가 다시 다른 탭을 누를 수 있어 동작이 꼬일 가능성이 있어서 로딩 플로우를 넣은 거 아닐 까 하는 (탭 연타 차단 역할) 숨은 역할도 알게 되었습니다.</li></ul><h4>데모 프로젝트</h4><ul><li><a href="https://github.com/kimkyuchul/iOS-LAB/tree/main/LiquidGlassTabBar">https://github.com/kimkyuchul/iOS-LAB/tree/main/LiquidGlassTabBar</a></li></ul><h4>참고 자료</h4><ul><li><a href="https://developer.apple.com/documentation/uikit/uiview/snapshotview(afterscreenupdates:)">https://developer.apple.com/documentation/uikit/uiview/snapshotview(afterscreenupdates:)</a></li><li><a href="https://developer.apple.com/documentation/TechnologyOverviews/adopting-liquid-glass">https://developer.apple.com/documentation/TechnologyOverviews/adopting-liquid-glass</a></li><li>카카오뱅크 iOS v2.60.0</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8ea52b0d45d1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[WWDC 2022] Link fast: Improve build and launch times]]></title>
            <link>https://medium.com/@kyuchul2/wwdc-2022-link-fast-improve-build-and-launch-times-55c702cd2f4e?source=rss-46a4ba84478------2</link>
            <guid isPermaLink="false">https://medium.com/p/55c702cd2f4e</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[wwdc]]></category>
            <category><![CDATA[xcode]]></category>
            <dc:creator><![CDATA[kyuchulkim]]></dc:creator>
            <pubDate>Fri, 24 Apr 2026 00:14:47 GMT</pubDate>
            <atom:updated>2026-04-24T00:17:59.689Z</atom:updated>
            <content:encoded><![CDATA[<h4>Static &amp; Dynamic Linking</h4><h3>Linking이란?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I19jPnz3nDxxIn66JEnXKA.png" /></figure><p>코드를 작성할 때 직접 작성한 코드뿐만 아니라 라이브러리(library)나 프레임워크(framework) 형태로 다른 사람이 작성한 코드도 사용합니다. 우리 코드가 이러한 라이브러리를 사용하기 위해서는 링커(linker)가 필요합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0Bj0om47uI7Bt4BWEsGHrQ.png" /></figure><p>linking에는 두 가지 종류가 있습니다.</p><ul><li><strong>Static Linking (정적 링킹)</strong>: 앱을 빌드할 때 발생합니다. 이는 앱 빌드 시간과 앱의 최종 크기에 영향을 줍니다.</li><li><strong>Dynamic Linking (동적 링킹)</strong>: 앱이 실행(launch)될 때 발생합니다. 이는 사용자가 앱을 실행할 때 기다려야 하는 시간에 영향을 줍니다.</li></ul><h3>Static Linking의 역사와 동작 원리</h3><h4>컴파일러의 분리</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FQczgyKCIEIg7v0fK4UQuw.png" /></figure><ul><li>초창기 프로그램은 매우 단순했고, 단 하나의 소스 파일만 존재 &amp; 빌드도 간단했습니다.</li><li>하지만 모든 소스 코드를 하나의 파일에 두는 것은 확장성이 없었습니다. 대용량 텍스트 파일을 편집하기 싫어서가 아니라, 진짜 이점은 <strong>빌드할 때마다 모든 함수를 다시 컴파일하지 않아도 된다는 점</strong>입니다.</li></ul><p>이 문제를 해결하기 위해 컴파일러를 두 부분으로 분리했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FQczgyKCIEIg7v0fK4UQuw.png" /></figure><ul><li><strong>첫 번째 부분</strong>: 소스 코드를 새로운 중간 파일인 <strong>”relocatable object” 파일(.o 파일)로 컴파일합니다.</strong></li><li><strong>두 번째 부분</strong>: .o 파일을 읽어서 실행 가능한 프로그램을 생성합니다. 이 두 번째 부분이 바로 우리가 부르는 <strong>ld, 즉 static linker(정적 링커)</strong>입니다.</li></ul><h4>Static Library의 등장</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fNi0NAnJLwpKujAMXJzpxw.png" /></figure><ul><li>소프트웨어가 발전하면서 사람들이 .o 파일들을 주고받게 되었습니다. 그런데 이게 점점 번거로워졌고, 누군가 <strong>“여러 개의 .o 파일을 하나의 ‘라이브러리’로 패키징할 수 있다면 좋지 않을까?”</strong>라고 생각했습니다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zqcGBjrUESr7Qpc7R0tbww.png" /></figure><ul><li>당시 파일들을 하나로 묶는 표준 방법은 아카이빙 도구 ar을 사용하는 것이었습니다.</li><li>여러 .o 파일을 ar로 묶어 아카이브를 만들 수 있고, 링커는 아카이브 파일에서 직접 .o 파일을 읽을 수 있도록 개선되었습니다.</li></ul><p>이것이 공통 코드를 공유하는 데 큰 개선이 되었고, 당시에는 단순히 라이브러리 또는 아카이브라고 불렸습니다. <strong>오늘날 우리는 이를 static library(정적 라이브러리)라고 부릅니다. (사진의 libc.a)</strong></p><h4>Selective Loading (선택적 로딩) 최적화</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*30fWR_kbSIBJsK4HaL_49A.png" /></figure><ul><li>라이브러리에서 수천 개의 함수가 최종 프로그램에 복사되면서, 정작 사용하는 함수는 몇 개 안 되는데도 프로그램이 매우 커지는 문제가 발생했습니다.</li><li>그래서 링커는 최적화가 추가되었습니다. <strong>링커는 static library(libc.a)의 모든 </strong><strong>.o 파일을 사용하는 대신, 정의되지 않은 심볼(undefined symbol)을 해결할 때만 static library에서 </strong><strong>.o 파일을 가져옵니다.</strong></li><li>이 덕분에 모든 C 표준 라이브러리 함수를 포함하는 큰 libc.a static library를 빌드할 수 있고, 모든 프로그램은 이 하나의 libc.a와 링크되지만 각 프로그램은 실제로 필요한 libc 부분만 가져갑니다. 이 모델은 오늘날까지도 유지되고 있습니다.</li></ul><h4>동작 시나리오 — 한 단계씩 따라가기</h4><pre>// main.c<br>extern void foo(void);<br>int main() { foo(); return 0; } // foo 호출<br><br>// foo.c<br>extern void bar(void);<br>void foo() { bar(); } // bar 호출<br><br>// bar.c<br>void bar() { /* implementation */ }<br>void unused() { /* not called */ } // 사용되지 않음<br><br>// baz.c<br>extern void undef(void);<br>void baz() { undef(); } // undef 호출</pre><ul><li>각각을 자기 자신의.o파일로 컴파일합니다. foo, bar, undef는 정의가 아니라 사용(undefined) 상태입니다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h_DMuyQcYtBuis8YZ3x7KA.png" /></figure><ul><li>bar.o와 baz.o를 하나의 static library로 묶고, 두 개의 .o파일과 static library를 링크한다고 가정해 봅니다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WdgeGOd64UCakRvYNNn7LQ.png" /></figure><p>링커는 명령줄 순서대로 파일을 처리합니다. 가장 먼저 찾는 것은 main.o입니다. 이를 로드하고 심볼 테이블에서 main 정의를 찾습니다. 동시에 main이 foo를 호출한다는 undefined를 발견합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J3fbMKTiEfiB9YFTw27P5w.png" /></figure><p>다음 파일 foo.o를 파싱합니다. 이로 인해 foo 정의가 추가되어 foo는 더 이상 undefined가 아닙니다. 하지만 bar라는 새로운 undefined 심볼이 추가됩니다.</p><ul><li>명령줄에 있는 모든 .o 파일을 로드한 후, 링커는 남아있는 undefined 심볼이 있는지 확인합니다. bar가 여전히 undefined이므로 라이브러리들을 살펴봅니다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p4-IIn6cbNUQ06dOaddAng.png" /></figure><p>static library의 bar.o가 bar를 정의하고 있음을 발견합니다. 그래서 아카이브에서 bar.o를 로드합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hbLSPkdoqkmBfNQmTi55ng.png" /></figure><p>다음으론 undefined 심볼이 없으므로 라이브러리 처리를 멈춥니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WwAvsGkyMq2QqjeQ13LzQQ.png" /></figure><p>그 다음 단계로, 프로그램의 모든 함수와 데이터에 주소를 할당하고 출력 파일에 복사합니다.</p><p><strong>중요한 점은 </strong><strong>baz.o는 static library에 있었지만 프로그램에 로드되지 않았다는 것입니다.</strong> 선택적 로딩 방식 때문입니다. (baz.o는 static library 안에 있었지만 어떤 undefined 심볼도 해결하지 않으므로 링커는 이를 로드하지 않음)</p><h3>What’s New in Apple’s Static Linker (Recent Id64 improvements)</h3><p>2022년 Apple은 Id64를 최적화 했습니다. 이번 링커는 많은 프로젝트에서 두 배 빠릅니다.</p><ul><li><strong>개발 머신의 코어를 더 잘 활용</strong>: 입력에서 출력 파일로 콘텐츠를 복사하는 작업, LINKEDIT의 다양한 부분을 병렬로 빌드하는 작업, UUID 계산과 코드사이닝 해시를 병렬로 처리하도록 변경했습니다.</li><li><strong>알고리즘 개선</strong>: exports-trie 빌더는 C++ string_view 객체를 사용하여 각 심볼의 문자열 슬라이스를 표현하면 매우 잘 작동한다는 것을 발견했습니다. 또한 바이너리의 UUID를 계산할 때 하드웨어 가속을 활용하는 최신 암호화 라이브러리를 사용했고, 다른 알고리즘도 개선했습니다.</li></ul><h3>Static Linking 개선을 위한 Best Practices</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C0fvmD3dpFFuRbEmm5FBeA.png" /></figure><p>활발히 변경되는 코드는 Static Library에서 빼기</p><ul><li>활발히 작업 중인 소스 파일이 static library로 빌드되도록 되어 있다면, <strong>빌드 시간이 느려집니다</strong>. 파일이 컴파일된 후 static library 전체가 목차(table of contents)를 포함해 다시 빌드되어야 하기 때문입니다. 이는 많은 추가 I/O를 유발합니다.</li><li><strong>Static library는 안정적인 코드(actively 변경되지 않는 코드)에 가장 적합합니다.</strong> 활발히 개발 중인 코드는 static library에서 빼서 빌드 시간을 줄이는 것을 고려해야 합니다.</li></ul><h4>-all_load 옵션</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gGmIv5nWHd_wEPJkRi23Ng.png" /></figure><p>Selective Loading(선택적 로딩)은 링커를 느리게 만드는 단점이 있습니다. 이유는 빌드를 재현할 수 있게(reproducible) 하고 전통적인 정적 라이브러리 시맨틱을 따르도록 하기 위해 <strong>링커는 고정된 직렬 순서로 정적 라이브러리를 처리</strong>해야 하기 때문입니다. 이는 ld64의 병렬화 이점 일부를 사용할 수 없게 만듭니다.</p><p>이러한 historical behavior가 정말로 필요하지 않다면, <strong>-all_load</strong> 옵션을 사용해 빌드를 빠르게 할 수 있습니다.</p><ul><li>이 옵션은 링커에게 모든 static library의 모든 .o 파일을 무조건 로드하라고 알려줍니다.</li><li>앱이 모든 static library의 콘텐츠 대부분을 선택적으로 로드하게 될 거라면 도움이 됩니다.</li><li>-all_load를 사용하면 링커가 모든 static library와 그 콘텐츠를 병렬로 파싱할 수 있습니다.</li></ul><blockquote>여러 static library가 동일한 심볼을 구현하고 있고, 명령줄 순서에 의존하여 어떤 구현을 사용할지 결정하는 트릭을 쓴다면 이 옵션은 사용하면 안 됩니다.</blockquote><p>또 다른 <strong>단점은 “사용되지 않는” 코드가 추가되어 프로그램이 더 커질 수 있다는 점</strong>입니다. 이를 보완하기 위해 <strong>-dead_strip 옵션</strong>을 사용할 수 있습니다. 이 옵션은 링커가 도달할 수 없는 코드와 데이터를 제거하도록 합니다. dead stripping 알고리즘은 빠르며 보통 출력 파일 크기를 줄여 비용을 충당합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*CJ8maFBKZGBbPwNke7OsXg.png" /></figure><ul><li>“Other Linker Flags” 에서 -all_load 를 설정할 수 있고, “Dead Code Stripping” 또한 설정이 가능</li></ul><h4>-no_exported_symbols 옵션</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nCPSTt7T2bYcQz7Q1VTEAA.png" /></figure><p>링커가 생성하는 LINKEDIT 세그먼트의 한 부분은 <strong>exports trie</strong>입니다. 이는 모든 익스포트된 심볼 이름, 주소, 플래그를 인코딩하는 prefix tree(접두사 트리)입니다</p><blockquote>LINKEDIT 세그먼트는 실행 파일 안에서 코드가 아닌, 링커와 로더가 사용하는 메타데이터 영역입니다. exports trie는 그 안에 있는 구조로, 바이너리가 외부에 공개하는 함수·심볼 목록을 빠르게 찾기 위해 저장한 색인 데이터입니다. (GPT 왈)</blockquote><p>모든 <strong>dylib(동적 라이브러리 파일 형식)</strong>는 익스포트된 심볼이 필요하지만, <strong>메인 앱 바이너리는 일반적으로 어떤 익스포트된 심볼도 필요하지 않습니다</strong>. 즉, 보통 메인 실행 파일에서 심볼을 조회하는 것은 없습니다.</p><p>이런 경우 앱 타겟에 -no_exported_symbols를 사용해 LINKEDIT의 trie 데이터 구조 생성을 건너뛸 수 있고, 이는 링크 시간을 개선합니다.</p><p>메인 실행 파일에 다시 링크되는 플러그인을 로드하거나, xctest 번들을 실행하기 위해 호스트 환경으로 앱을 사용한다면, 모든 익스포트가 필요하므로 이 옵션을 사용하면 안 됩니다.</p><p><em>한 큰 앱은 약 100만 개의 익스포트된 심볼을 가지고 있었고, 링커가 이를 위한 exports trie를 빌드하는 데 2~3초가 걸렸습니다. </em><em>-no_exported_symbols를 추가하니 그 앱의 링크 시간이 2~3초 단축되었습니다.</em></p><h4>-no_deduplicate 옵션</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KGnN3cu13_o7jPqGlXvajw.png" /></figure><p>명령은 같지만 이름이 다른 함수를 병합하기 위해서 새로운 패스를 추가했습니다. (<strong>C++ template expansion</strong>으로 인해 그런 함수가 많이 생길 수 있습니다.)</p><p>하지만 이것은 비싼 알고리즘입니다. 링커가 모든 함수의 명령어를 재귀적으로 해싱하여 중복을 찾아야 하기 때문입니다. 비용 때문에 알고리즘을 제한하여 링커가 weak-def 심볼만 보도록 했습니다(인라인되지 않은 C++ template expansion에 대해 컴파일러가 방출하는 심볼들).</p><p><strong>de-dup은 size 최적화</strong>입니다. <strong>Debug 빌드는 빠른 빌드가 목적이지 size가 목적이 아니므로</strong>, Xcode는 Debug 구성에서 링커에 -no_deduplicate를 전달해 기본적으로 de-dup 최적화를 비활성화합니다. (중복 허용).</p><p>또한 clang link line을 -O0(no optimization)으로 실행하면 clang은 no-dedup 옵션을 링커에 전달합니다.</p><p>요약하면 C++를 사용하고 custom build가 있는 경우, 즉 Xcode에서 비표준(non-standard) 구성을 사용하거나 다른 빌드 시스템을 사용하는 경우 링크 시간을 개선하기 위해 디버그 빌드에 -no_deduplicate가 추가되었는지 확인해야 합니다.</p><h4>간단하게 요약</h4><p><strong>all_load</strong></p><ul><li>정적 라이브러리(.a) 안의 모든 오브젝트 파일을 강제로 전부 링크하는 옵션입니다. 카테고리, Objective-C 런타임 등록 누락 문제 해결에 쓰이지만 바이너리 크기가 커질 수 있습니다.</li></ul><p><strong>no_exported_symbols</strong></p><ul><li>메인 실행 파일에서 외부로 공개할 심볼 목록(exports trie)을 생성하지 않도록 하는 옵션입니다. 앱 바이너리 크기를 줄이고 LINKEDIT 영역을 최적화하는 데 도움이 됩니다.</li></ul><p><strong>no_deduplicate</strong></p><ul><li>링커가 동일한 문자열·상수·데이터를 하나로 합치는 중복 제거 최적화를 하지 않도록 하는 옵션입니다. 바이너리 크기는 다소 커질 수 있지만, 링크 시간을 줄여 Debug 빌드 속도 개선에 활용됩니다. (대규모 C++ 프로젝트나 커스텀 빌드 환경에서 주로 사용)</li></ul><h4>-Objc 옵션</h4><p>추가로 Tuist 사용 시 Other Linker Flags에서 많이 사용되는 -Objc 옵션을 정리해보았습니다.</p><p>ObjC 옵션은 <strong>정적 라이브러리(.a) 안에 들어있는 Objective-C 클래스와 카테고리(category) 구현 파일을 링커가 자동으로 모두 로드하도록 하는 옵션</strong>입니다.</p><p>기본적으로 링커는 <strong>실제로 참조된 오브젝트 파일만 링크</strong>하는데, Objective-C의 category는 코드에서 직접 심볼 참조가 없어 누락될 수 있습니다. (런타임에 unrecognized selector sent to instance 발생) <a href="https://tuist.dev/ko/docs/guides/features/projects/dependencies#objectivec-dependencies">관련 tuist 문서</a></p><p><strong>all_load와 차이</strong></p><ul><li><strong>ObjC</strong>: Objective-C 관련 오브젝트만 적극 로드</li><li><strong>all_load</strong>: 라이브러리 내 모든 오브젝트를 전부 로드</li></ul><h3>Static Library 사용 시 주의사항</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rl98kp1eg5FBKTJC-zoTFA.png" /></figure><p><strong>Surprise 1: 의도한 코드가 포함되지 않음</strong></p><p>소스 코드가 static library로 빌드되어 앱이 링크하지만, 그 코드가 최종 앱에 들어가지 않는 경우가 있습니다. 예를 들어 어떤 함수에 attribute used를 추가했거나, Objective-C 카테고리가 있는 경우입니다.</p><p>링커의 선택적 로딩 때문에, static library의 해당 object 파일들이 링크 중에 필요한 어떤 심볼도 정의하지 않으면 링커가 로드하지 않습니다. (링커가 필요 심볼 없다고 object file을 안 가져오는 문제 때문에 위에서 알아본 -ObjC가 필요)</p><p><strong>Surprise 2: dead stripping이 문제를 숨김</strong></p><p>보통 missing symbol이나 duplicate symbol은 링커의 오류를 유발합니다. 하지만 dead stripping은 main부터 시작하여 모든 코드와 데이터에 대해 reachability pass(도달 가능한 패스)를 실행하며, missing symbol이 도달할 수 없는 코드에서 온 것이라면 링커가 missing symbol 에러를 억제합니다.</p><p>static library에서 duplicate symbol(중복되는 심볼)이 있으면 링커는 첫 번째를 선택하고 에러를 내지 않습니다.</p><p><strong>Surprise 3: 여러 framework에 같은 static library 포함</strong></p><p>static library가 여러 framework에 통합되는 경우입니다. 각 framework는 독립적으로 잘 작동하지만, 어떤 시점에 어떤 앱이 두 framework를 모두 사용하면 다중 정의 때문에 이상한 런타임 이슈가 발생합니다. 가장 일반적인 사례는 <strong>같은 클래스 이름의 다중 인스턴스에 대한 Objective-C 런타임 경고입니다.</strong></p><p><em>ex) FrameworkA와 FrameworkB가 둘 다 같은 AnalyticsCore.a를 품고 있으면, 앱 실행 시 동일 클래스(ACTracker)가 두 번 등록됩니다. 그러면 “둘 중 어느 구현을 쓸지 모른다”는 Objective-C 런타임 경고와 예측 불가 동작이 발생합니다.</em></p><h3>Dynamic Linking — 역사와 동작 원리</h3><h4>Dynamic Library의 등장</h4><p>Static linking은 시간이 지남에 따라 점점 더 많은 라이브러리가 추가되면서 최종 프로그램이 커지고, 결과적으로 static link 시간도 증가하는 문제가 있습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AA8y_9yuuF5QMaCL8jgIQQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HRHr__IwJm0FQuOG5Fq8qQ.png" /></figure><p><strong>ar을 </strong><strong>ld로 </strong>바꾸고(아카이브 도구 ar 을 -&gt; 정적 링커 ld 로 변경) <strong>출력 라이브러리를 실행 가능한 바이너리(executable binary)로 만들면 어떨까?</strong></p><p>이것이 1990년대 dynamic library의 시작이었습니다. 줄여서 <strong>dylib</strong>이라고 부릅니다(다른 플랫폼에서는 DSO나 DLL로 알려짐)</p><h4>Dynamic Library의 핵심 — 약속(Promise)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TgCxRpKYPt25ifnncJswQw.png" /></figure><p>핵심은 <strong>static linker가 dynamic library와의 링크를 다르게 처리한다는 것</strong>입니다. 라이브러리에서 코드를 최종 프로그램으로 복사하는 대신, 링커는 일종의 <strong>“약속(promise)”만 기록</strong>합니다. 즉, dynamic library에서 사용된 심볼 이름과 라이브러리의 런타임 경로만 기록합니다.</p><ul><li><strong>정적</strong> 라이브러리 : 최종 프로그램으로 <strong>코드를 복사</strong></li><li><strong>동적</strong> 라이브러리 : <strong>동적 라이브러리</strong>에서 사용되는 <strong>심볼 이름</strong>과 런타임 시 <strong>라이브러리의 경로</strong>와 같은 <strong>일종의 약속</strong>을 기록</li></ul><p><strong>dynamic library</strong> 장점은 다음과 같습니다.</p><ul><li><strong>프로그램 파일 크기가 통제 가능</strong>: 자신의 코드와 런타임에 필요한 dynamic library 목록만 포함합니다.</li><li><strong>프로그램의 static link 시간은 코드 크기에 비례</strong>하며, 링크하는 dylib의 수와 무관합니다.</li><li><strong>Virtual Memory 시스템이 빛을 발함</strong>: 여러 프로세스에서 동일한 dynamic library를 사용할 때, VM 시스템은 그 dylib에 대해 동일한 RAM 물리 페이지를 모든 프로세스에서 재사용합니다.</li></ul><p>최종 프로그램은 단순히 자신의 <strong>코드</strong>와, 런타임에 필요한 <strong>동적 라이브러리 목록</strong>만을 포함할 뿐, <strong>동적 라이브러리 코드의 복사본은 포함하지 않기 때문에</strong> 프로그램의 <strong>크기</strong>는 <strong>사용자의 통제</strong> 하에 있게 됩니다.</p><h4>Dynamic Library의 비용</h4><p>동적 라이브러리 사용의 이점은 <strong>빌드 시간 단축</strong>이 있습니다. 그러나 비용도 따릅니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_MeND11LtkXH0nseuVte9Q.png" /></figure><ul><li><strong>빌드 시간은 단축 되었지만 앱 실행이 더 느림(launching)</strong>: 더 이상 하나의 프로그램 파일을 로드하는 것이 아닙니다. 모든 dylib도 로드되고 함께 연결되어야 합니다. 즉, 일부 링킹 비용이 빌드 시간에서 launch 시간으로 미룬거가록 볼 수 있습니다.</li><li><strong>dirty page가 더 많음</strong>: static library 케이스에서는 링커가 모든 static library의 모든 글로벌을 메인 실행 파일의 동일한 DATA 페이지에 함께 배치합니다. 하지만 dylib에서는 각 라이브러리가 자체 DATA 페이지를 가집니다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Cec0TO3ooDBurlWEg8qYAA.png" /></figure><ul><li><strong>dynamic linker 필요</strong>: 빌드 시 실행 파일에 기록된 promise를 런타임에 이행해줄 무언가가 필요합니다. 이것이 <strong>dyld(dynamic linker)</strong>입니다. (정적 링커는 ld, 동적 링커는 dyld).</li></ul><h4>런타임에서 Dynamic Linking이 동작하는 방식</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WhTViinZQD-HV60pZeXwng.png" /></figure><p>executable binary는 <strong>segment</strong> (일반적으로 TEXT, DATA, LinkedIT) <strong>로 나뉩</strong>니다.</p><ul><li>세그먼트는 항상 OS 페이지 크기의 배수입니다.</li><li>각 세그먼트는 다른 권한(permission)을 가집니다. (예를 들어 TEXT 세그먼트는 “execute” 권한을 가지므로 CPU가 페이지의 바이트들을 머신 코드 명령으로 처리할 수 있습니다.)</li></ul><p>런타임에 dyld는 실행 파일들을 각 세그먼트의 권한으로 메모리에 mmap()해야 합니다.</p><ul><li>세그먼트가 페이지 크기와 페이지 정렬되어 있기 때문에, virtual memory 시스템이 프로그램이나 dylib 파일을 VM 범위의 backing store(백업 저장소)로 설정하기가 간단합니다.</li><li><strong>해당 페이지에 메모리 액세스가 발생하기 전까지는 어떤 것도 RAM에 로드되지 않음</strong>을 의미합니다. 액세스가 발생하면 page fault가 트리거되어 VM 시스템이 파일의 적절한 부분을 읽고 필요한 RAM 페이지를 그 콘텐츠로 채웁니다.</li></ul><p>하지만 매핑만으로는 충분하지 않고 어떻게든 프로그램은 연결(link)되거나 dylib에 바인딩되어야 하는데, 이를 위해서 ‘fix ups’이란 개념이 존재</p><h4>Fix-ups (수정 작업)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y1NKQ3Dvps6Cz26mG1SQlw.png" /></figure><p>TEXT 세그먼트는 불변(immutable)이며, 코드 사이닝 기반 시스템에서는 그래야만 합니다. 그렇다면 malloc()을 호출하는 함수는 어떻게 동작할까요? _malloc의 상대 주소는 프로그램이 빌드된 시점에 알 수 없습니다.</p><p>static linker가 malloc이 dylib에 있다는 것을 보고 <strong>call site를 변환합니다</strong>. call site는 같은 TEXT 세그먼트 내에 링커가 합성한 <strong>stub</strong>에 대한 호출이 됩니다. 따라서 상대 주소가 빌드 시 알려지므로 BL 명령이 올바르게 형성될 수 있습니다. 이 stub은 DATA에서 포인터를 로드하고 그 위치로 점프합니다. 즉, <strong>런타임에 TEXT는 변경할 필요가 없고, dyld는 DATA만 변경합니다.</strong></p><p><em>malloc()을 직접 호출하지 않고, </em><strong><em>고정된 stub을 호출 → stub이 DATA에 적힌 실제 주소로 이동</em></strong><em>하기 때문에 실행 중 TEXT를 수정할 필요가 없습니다.</em></p><h4>두 종류의 Fix-up: Rebase와 Bind</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZxcfzHG5Me6xgezSRQWB0Q.png" /></figure><p><strong>Rebase (재배치)</strong></p><ul><li>dylib나 앱이 자기 자신 안을 가리키는 포인터를 가지는 경우입니다. <strong>ASLR(Address Space Layout Randomization)</strong>이라는 보안 기능 때문에 dyld는 dylib를 무작위 주소에 로드합니다. 그 결과 내부 포인터들은 빌드 시 설정될 수 없고, dyld가 launch 시 이를 조정(rebase)해야 합니다.</li><li>디스크 상에서 이 포인터들은 dylib가 주소 0에 로드되었을 때의 타겟 주소를 담고 있습니다. 그래서 LINKEDIT는 각 rebase 위치만 기록하면 됩니다. dyld는 dylib의 실제 로드 주소를 각 rebase 위치에 더해 올바르게 fix-up할 수 있습니다.</li><li>Rebase는 <strong>ASLR 때문에 바뀐 실제 로드 주소에 맞춰, 바이너리 내부 포인터들을 시작 시점에 다시 계산해 고치는 작업</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ccSTQsB4n8m-fo8Ybwlpjw.png" /></figure><p><strong>Bind (바인딩)</strong></p><ul><li>심볼 참조입니다. 즉, 타겟이 숫자가 아니라 심볼 이름입니다. 예를 들어 malloc 함수에 대한 포인터입니다. 문자열 _malloc이 LINKEDIT에 저장되고, dyld는 그 문자열을 사용해 libSystem.dylib의 exports trie에서 malloc의 실제 주소를 찾습니다. 그런 다음 dyld는 그 값을 bind에 명시된 위치에 저장합니다.</li><li><strong>Bind = 이름만 적어둔 외부 심볼(_malloc)을 런타임에 실제 메모리 주소로 연결해서 포인터 자리에 써 넣는 작업</strong>입니다.</li></ul><h4>Rebase, Bind와 차이</h4><ul><li><strong>Rebase</strong> = 자기 자신 내부 주소 보정</li><li><strong>Bind</strong> = 외부 라이브러리 심볼 주소 연결 (malloc, UIKit 등)</li></ul><h4>Chained Fixups (새로운 인코딩 방식)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5Rhd7KLlrS0jofUQ-_pFkQ.png" /></figure><p>WWDC22에서는 fixups을 인코딩하는 새로운 방법으로 ‘chained fixups’을 새롭게 발표했습니다. (chained fixups에 대한 런타임 지원은 iOS 13.4 이상)</p><p><strong>첫 번째 장점</strong>은 LINKEDIT를 더 작게 만든다는 점입니다. 새 형식은 모든 fix-up 위치를 저장하는 대신, <strong>각 DATA 페이지에서 첫 번째 fix-up 위치만 저장</strong>하고, 나머지 정보는 <strong>DATA 세그먼트 자체에</strong>, 결국 fix-up이 설정될 위치에 인코딩됩니다.</p><p>이 새 형식은 fix-up 위치들이 함께 “체인(chain)”되어 있다는 사실에서 이름을 얻었습니다. LINKEDIT는 첫 번째 fix-up이 어디 있는지만 말하고, DATA의 64비트 포인터 위치에서 일부 비트는 다음 fix-up 위치로의 오프셋을 담습니다. 또한 fix-up이 bind인지 rebase인지를 나타내는 비트도 함께 패킹됩니다.</p><ul><li>bind이면 나머지 비트는 심볼의 인덱스입니다.</li><li>rebase이면 나머지 비트는 이미지 내 타겟의 오프셋입니다.</li></ul><p><strong><em>수정해야 할 주소 목록을 따로 길게 저장하지 않고, 포인터들끼리 다음 수정 위치를 알려주는 연결 리스트처럼 만들어 dyld가 따라가며 처리하는 방식</em></strong></p><h4>dyld의 작동 흐름과 Page-in Linking</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xtowV3RDWl9TSqM1-SPIuQ.png" /></figure><p>dyld는 다음 순서로 동작합니다.</p><ol><li>메인 실행 파일(예: 앱)을 시작점으로 잡고, mach-o(**Mach-O는 Apple 운영체제에서 앱과 라이브러리가 사용하는 실행 파일 구조 포맷)**를 파싱하여 의존성 dylib들을 찾습니다.</li><li>그 dylib들을 찾아 mmap()합니다.</li><li>각각에 대해 재귀적으로 mach-o 구조를 파싱하고 추가 dylib를 로드합니다.</li><li>모든 것이 로드되면 dyld는 필요한 모든 bind 심볼을 조회하고 그 주소를 사용해 fix-up을 수행합니다</li><li>모든 fix-up이 끝나면 initializer를 bottom-up으로 실행합니다.</li></ol><p>앱이 실행될 때마다 <strong>녹색 단계들이 매번 동일</strong>하다는 것을 깨닫고, 새로운 dyld 기술을 발표했습니다. 프로그램과 dylibs가 변경되지 않는 한, 녹색으로 표시된 모든 단계는 <strong>첫 번째 실행에서 캐시</strong>되고 후속 실행에서는 <strong>재사용</strong> 될 수 있습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YRNtQNDe_zkoQYJnYxRfGQ.png" /></figure><ul><li><strong>page-in linking</strong>이라는 새로운 dyld 기능을 발표합니다. dyld가 launch 시 모든 dylib에 모든 fix-up을 적용하는 대신, <strong>커널이 page-in 시점에 DATA 페이지에 대해 lazy하게 fix-up을 적용할 수 있습니다.</strong></li><li>이 메커니즘은 <strong>dirty memory와 launch 시간을 줄입니다</strong>.</li><li>또한 DATA_CONST 페이지가 clean해진다는 의미이므로, TEXT 페이지처럼 evict되고 재생성될 수 있어 메모리 압박을 줄입니다.</li><li>주의할 것은 dyld가 이 매커니즘을 launch 중에만 사용한다는 것입니다. (나중에 dlopen()된 dylib들은 Page-in linking되지 못하는데, 이 경우에는 dyld는 전통적인 경로를 사용하고 fixups을 dlopen 호출 중에 적용됨)</li></ul><h3>Dynamic Linking 개선을 위한 Best Practices</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HtYXsiiXX3aszE5FWgqNCg.png" /></figure><p>동적 링크의 성능 개선을 위해 가능한 것 중에서는 기존에 dyld는 이미 동적 링킹의 많은 부분을 최적화 했습니다. 따라서 우리가 제어할 수 있는건 dylib의 수입니다.</p><p><strong>dylib의 개수</strong></p><ul><li>dylib가 많을수록 dyld가 로드해야 할 작업이 많아집니다. 더 적을수록 dyld가 수행할 작업이 적어집니다. (앱 시작 시 A.framework, B.framework, C.framework … 수십 개를 각각 로드하면 의존성 확인·매핑 작업이 늘어 실행 시작이 느려질 수 있다)</li></ul><p><strong>Static initializer 주의</strong></p><ul><li>pre-main에 항상 실행되는 코드입니다. <strong>Static initializer에서 I/O나 네트워킹을 하지 마세요.</strong> 몇 밀리초 이상 걸릴 수 있는 어떤 것도 절대 initializer에서 하면 안 됩니다. (전역 객체 초기화 코드에서 파일 읽기, DB 오픈, 네트워크 요청을 하면 main() 진입 전 앱 실행이 지연)</li></ul><p><strong>Static과 Dynamic library의 sweet spot 찾기:</strong></p><ul><li>static library가 너무 많으면 → 반복적인 빌드/디버그 사이클이 느려짐</li><li>dynamic library가 너무 많으면 → launch 시간이 느려져 사용자가 알아챔</li><li>올해 ld64를 빠르게 만들었으므로 sweet spot이 바뀌었을 수 있음 — <strong>더 많은 static library 또는 더 많은 source 파일을 직접 앱에 사용해도 동일한 빌드 시간을 유지할 수 있음 (static library를 더 많이 사용해라?)</strong></li></ul><p><strong>dyld_usage</strong></p><ul><li>dyld_usage로 dyld가 무엇을 하고 있는지 trace를 얻을 수 있습니다</li></ul><p><strong>dyld_info</strong></p><ul><li>dyld_info로 디스크의 바이너리와 현재 dyld cache를 검사할 수 있습니다. 많은 옵션이 있지만 exports와 fixups를 보는 방법이 핵심입니다.</li></ul><pre># 모든 fixup 위치와 타겟 보기<br>dyld_info -fixups MyApp.app/MyApp<br><br># dylib의 모든 익스포트된 심볼과 dylib 시작부터의 오프셋 보기<br>dyld_info -exports /System/Library/Frameworks/Foundation.framework/Foundation<br><br># 익스포트된 심볼 개수 세기 (3-3 절에서 사용된 명령)<br>dyld_info -exports MyApp.app/MyApp | wc -l</pre><h3>마무리</h3><ul><li>Static과 Dynamic library의 트레이드오프를 이해했다면, 자신의 앱이 sweet spot에 있는지 검토할 것</li><li>큰 앱이 있고 링크가 오래 걸린다면 새로운 빠른 링커가 포함된 <strong>Xcode 14</strong>를 시도할 것</li><li>static link를 더 빠르게 하고 싶다면 세 가지 링커 옵션(all_load, no_exported_symbols, no_deduplicate)이 빌드에 적합한지 확인할 것</li><li>앱과 임베디드 framework를 <strong>iOS 13.4 이상</strong>으로 빌드하여 chained fixups를 활성화하면 앱이 더 작아지고 iOS 16에서 더 빠르게 launch되는지 확인할 것</li></ul><h4>참고자료</h4><ul><li><a href="https://developer.apple.com/videos/play/wwdc2022/110362/">https://developer.apple.com/videos/play/wwdc2022/110362/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=55c702cd2f4e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SwiftUI에서 WKWebView 통신 재설계 (2)]]></title>
            <link>https://medium.com/@kyuchul2/swiftui%EC%97%90%EC%84%9C-wkwebview-%ED%86%B5%EC%8B%A0-%EC%9E%AC%EC%84%A4%EA%B3%84-2-2d2e4d35369f?source=rss-46a4ba84478------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d2e4d35369f</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[webview]]></category>
            <category><![CDATA[swiftui]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[proxy]]></category>
            <dc:creator><![CDATA[kyuchulkim]]></dc:creator>
            <pubDate>Sat, 11 Apr 2026 11:18:13 GMT</pubDate>
            <atom:updated>2026-04-11T16:36:53.210Z</atom:updated>
            <content:encoded><![CDATA[<h4>Proxy 패턴으로 네이티브 → 웹 명령형 호출 구조 만들기</h4><h3>들어가며</h3><p>1편에서는 <a href="https://medium.com/@kyuchul2/swiftui%EC%97%90%EC%84%9C-wkwebview-%ED%86%B5%EC%8B%A0-%EC%9E%AC%EC%84%A4%EA%B3%84-1-11dd79f6d70d">웹 → 네이티브 방향의 브릿지를 Phantom Type과 화면별 Bridge enum으로 재설계한 과정</a>을 다뤘습니다.</p><p>이번 글은 반대 방향, <strong>네이티브 → 웹 방향의 통신을 재설계한 과정</strong>을 풀어보려고 합니다.</p><p>결론부터 말하면, 선언형만으로는 풀리지 않았고 <strong>명령형 Proxy 패턴과 공존시키는 구조</strong>로 만들게 되었습니다.</p><p>1편에서 본 것처럼 웹 → iOS 방향은 WKScriptMessageHandler로 들어오는 이벤트를 선언적으로 구독하면 자연스러웠지만, 반대 방향인 iOS → 웹은 evaluateJavaScript로 JS 실행을 직접 명령해야 하는 호출이라 명령형이 더 잘 어울렸습니다.</p><h3>왜 재설계가 필요했나</h3><pre>// 기존 웹뷰에서 사용 방식<br>@State var webView = Webview(url: URL(string: &quot;...&quot;)!)<br>// ...<br>self.webView.evaluateJavaScript(&quot;doneTest()&quot;)<br><br>// 1편에서 브릿지 방식 재설계 후 방식<br>@State var webView = WebView&lt;Bridge&gt;(url: URL(string: &quot;...&quot;)) { bridge in<br>  // @State 기본값에서 self 캡처 불가<br>}</pre><ul><li>기존엔 외부에서 evaluateJavaScript를 호출할 일이 있을 때, 웹뷰를 @State로 인스턴스화해 JS 호출이 가능하도록 쓰여지고 있었습니다.</li><li>WebView를 WebView&lt;Bridge&gt; 형태로 바꾸면서, 웹뷰 인스턴스화 방식을 사용 하지 못하게 되었습니다. 제네릭과 onBridge 클로저를 init에서 받도록 설계했기 때문입니다.</li></ul><h3>1차 구현: Binding + Progressive Disclosure</h3><p>외부 JS 호출도 결국 <strong>“웹뷰의 선택적 동작”</strong>으로 생각하고, 체이닝 modifier로 바인딩하는 구조를 생각했습니다.</p><blockquote><strong>Progressive Disclosure</strong>는 init에는 필수 파라미터만 두고, 선택적 설정은 체이닝 modifier(.font(), .padding() 처럼)로 빼는 SwiftUI 네이티브 API 설계 방식 <a href="https://developer.apple.com/videos/play/wwdc2022/110353/">(WWDC22 “Design protocol interfaces in Swift)</a></blockquote><pre>struct WebView&lt;Bridge: BridgeParsable&gt;: UIViewRepresentable {<br>  private let urlString: String<br>  fileprivate var jsEvent: Binding&lt;JSEvent?&gt;?<br><br>  // ...<br>}<br><br>extension WebView {<br>  /// JS 이벤트 바인딩 — 값이 바뀌면 매핑된 JavaScript 실행<br>  func evaluateJavaScript(_ event: Binding&lt;JSEvent?&gt;) -&gt; Self {<br>    var view = self<br>    view.jsEvent = event<br>    return view<br>  }<br>}<br><br>// 사용부<br>enum JSEvent {<br>  case doneImageUpload<br>  ...<br>}<br><br>struct ImageUploadView: View {<br>  @State private var jsEvent: JSEvent?<br><br>  var body: some View {<br>    WebView(urlString: url) { bridge in ... }<br>      .evaluateJavaScript($jsEvent)<br>  }<br>}</pre><ul><li>WebView 내부에서는 @Binding&lt;JSEvent?&gt;을 받아, 값이 바뀌는 순간 매핑된 JSEvent로 evaluateJavaScript가 호출되는 방식이였습니다.</li></ul><h4>해당 방식 문제점: evaluateJavaScript 리턴값을 받을 수 없음</h4><pre>let height = try await webView.evaluateJavaScript(&quot;document.body.scrollHeight&quot;)</pre><p><strong>evaluateJavaScript</strong> 메서드는 리턴값을 받을 수 있습니다.</p><ul><li>프론트엔드와 협의한 JS 함수 호출: 웹 쪽에서 정의한 함수의 리턴값을 그대로 받을 수 있음</li><li>브라우저 내장 API 호출: document.body.scrollHeight 같은 웹 페이지 정보를 객체로 받아올 수 있음</li></ul><p>Binding으로는 evaluateJavaScript 메서드 호출까진 가능하나, 리턴값을 호출부로 돌려줄 자연스러운 경로가 존재하지 않았습니다. <strong>웹뷰에 직접 접근하지 않으면서도 직접 명령이 가능한 구조</strong>가 필요했습니다.</p><h3>2차 구현: Proxy 패턴 활용</h3><p>직접 명령이 필요한 동작(evaluateJavaScript, takeSnapshot 등)을 대리자에 모아두고, 외부는 웹뷰가 아니라 이 대리자를 통해서만 명령을 전달하는 구조를 생각했고, <strong>Proxy 패턴</strong>이 떠올랐습니다.</p><h3>Proxy 패턴</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DEMORjizIGqF6ixFK0j40g.png" /></figure><ul><li><strong>원본 객체에 직접 접근하는 대신, 그 앞에 대리자(Proxy) 를 두고 대리자를 통해서만 명령을 전달하는 구조</strong>입니다. 원본의 수명·접근 권한을 대리자가 관리하므로, 외부는 원본의 존재나 생성 시점을 몰라도 됩니다.</li></ul><pre>// 원본<br>  final class Printer {<br>    func print(_ text: String) {<br>      Swift.print(&quot;🖨️ \\(text)&quot;)<br>    }<br>  }<br><br>  // 대리자 — 원본을 감싸고 동일한 인터페이스 제공<br>  final class PrinterProxy {<br>    private let printer = Printer()<br><br>    func print(_ text: String) {<br>      printer.print(text)<br>    }<br>  }<br><br>  // 외부는 원본(Printer)을 몰라도 됨. Proxy만 사용.<br>  let proxy = PrinterProxy()<br>  proxy.print(&quot;hello&quot;)</pre><ul><li>외부에서는 원본(Printer)의 존재를 알 필요 없이 Proxy만 들고 명령을 내립니다.</li><li>WebView에 대입하면, WKWebView를 숨기고 명령 API 표면만 노출하는 <strong>WebViewProxy</strong>로 구성 할 수 있었습니다.</li></ul><h3>WebViewProxy 구현</h3><pre>@MainActor<br>  final class WebViewProxy: ObservableObject {<br>    /// 외부 메서드가 사용하는 접근 경로<br>    private var webView: WKWebView { ... }<br>    /// makeUIView에서 주입된 WKWebView — weak로 참조해 메모리 누수 방지<br>    weak var _webView: WKWebView? { ... }<br>    <br>    @discardableResult<br>    func evaluate&lt;T&gt;(_ command: JSCommand&lt;T&gt;) async throws -&gt; T? {<br>      try await webView.evaluateJavaScript(command.script) as? T<br>    }<br>    <br>    func takeSnapshot() async throws -&gt; UIImage { ... }<br>    func createPDF() async throws -&gt; Data { ... }<br>    ...<br>    ...<br>  }</pre><ul><li>내부 WKWebView를 weak로 참조하면서, evaluateJavaScript·takeSnapshot·createPDF 같은 명령형 동작을 메서드로 노출합니다. 외부는 WKWebView를 직접 알 필요 없이, <strong>Proxy</strong>를 통해 필요한 명령만 보내는 구조입니다.</li></ul><pre>struct WebView: UIViewRepresentable {<br>  private let proxy: WebViewProxy?<br><br>  init(<br>    proxy: WebViewProxy? = nil,<br>    // ...<br>  ) {<br>    self.proxy = proxy<br>    // ...<br>  }<br><br>  func makeUIView(context: Context) -&gt; WKWebView {<br>    let webView = WKWebView(frame: .zero, configuration: configuration)<br>    proxy?._webView = webView<br>    return webView<br>  }<br>}</pre><ul><li>WKWebView의 소유권은 SwiftUI(UIViewRepresentable)가 갖고, Proxy는 weak 참조로 빌려 쓰는 형태 입니다. WebView가 메모리에서 해제되면 Proxy의 참조도 자연스럽게 nil이 되므로 순환 참조로 인한 메모리 누수가 발생하지 않습니다.</li></ul><pre>struct SomeWebView: View {<br>    @StateObject private var proxy = WebViewProxy()<br>    @State private var scrollHeight: CGFloat = 0<br><br>    var body: some View {<br>      VStack {<br>        WebView(urlString: url, proxy: proxy)<br><br>        Button(&quot;스크롤 높이 가져오기&quot;) {<br>          Task { scrollHeight = try await proxy.evaluate(.scrollHeight) ?? 0 }<br>        }<br><br>        Text(&quot;높이: \\(scrollHeight)&quot;)<br>      }<br>    }<br>  }</pre><ul><li>레거시 웹뷰에서는 JS 호출을 위해 웹뷰 인스턴스를 @State로 붙잡아둬야 했지만, 이제는 <strong>Proxy만 들고 있으면 웹뷰를 알 필요 없이 명령을 보내고 결과</strong>까지 받을 수 있습니다.</li><li>여기서 한발자국 더 나아가, Proxy를 뷰에서 직접 @StateObject로 만들고 WebView에 넘기는 과정을 SwiftUI스럽게 풀어보면 어떨까 생각이 들었습니다.</li></ul><h4>WebViewReader</h4><pre>// ScrollViewReader — 명령형 스크롤 제어를 클로저로 주입<br>  ScrollViewReader { proxy in<br>    ScrollView {<br>      // ...<br>      Button(&quot;맨 위로&quot;) {<br>        proxy.scrollTo(&quot;top&quot;)<br>      }<br>    }<br>  }<br><br>  // GeometryReader — 레이아웃 측정값을 클로저로 주입<br>  GeometryReader { geometry in<br>    Text(&quot;너비: \\(geometry.size.width)&quot;)<br>  }</pre><ul><li>SwiftUI의 “상태 → UI” 단방향 흐름을 깨지 않으면서도 명령형 접근을 허용하는 구조를 생각해봤습니다. SwiftUI 개발 시 자주 사용하던 <strong>ScrollViewReader와 GeometryReader</strong>가 그 예시로 떠올랐습니다.</li></ul><pre>/// WebView에 대한 명령형 호출 Proxy.<br>  ///<br>  /// - Important: `WebViewReader` 블록 안에 반드시 `WebView`를 포함해야 합니다.<br>  ///   `WebView` 없이 Proxy를 사용하면 런타임 에러가 발생합니다.<br>  struct WebViewReader&lt;Content: View&gt;: View {<br>    @StateObject private var proxy = WebViewProxy()<br>    private let content: (WebViewProxy) -&gt; Content<br><br>    init(@ViewBuilder content: @escaping (WebViewProxy) -&gt; Content) {<br>      self.content = content<br>    }<br>    ...<br>    ...<br>  }<br>  <br>  // 사용부<br>  WebViewReader { proxy in<br>    VStack {<br>      PWWebView(urlString: url, proxy: proxy)<br><br>      Button(&quot;스크롤 높이 가져오기&quot;) {<br>        Task { let height = try await proxy.evaluate(.scrollHeight) }<br>      }<br>    }<br>  }</pre><ul><li>Reader 내부에서 @StateObject로 Proxy를 생성하고, @ViewBuilder 클로저의 파라미터로 넘겨줍니다. Content: View 제네릭 덕분에 블록 안에 어떤 뷰 조합이든 들어올 수 있고, ScrollViewReader가 ScrollViewProxy를 클로저로 주입하는 것과 동일한 구조입니다.</li><li>한 가지 다른 점은, ScrollViewReader 안에 ScrollView가 없으면 proxy.scrollTo()가 조용히 무시되지만, WebViewReader에서는 WebView 없이 Proxy를 사용하면 fatalError가 발생합니다.<strong>(Proxy에 WKWebView가 연결되지 않았기 때문)</strong> 웹뷰 없이 JS를 호출하는 건 명백한 실수이기 때문에, 조용히 넘어가는 것보다 즉시 드러나는 쪽을 택했습니다.</li></ul><h3>마치며</h3><p>1편(웹 → 네이티브)과 2편(네이티브 → 웹)을 거치면서, SwiftUI 웹뷰 통신 구조를 재설계 하고 적용했습니다.</p><ul><li>웹 → 네이티브: Phantom Type 기반 선언형 구독. 화면별 Bridge enum으로 이벤트를 타입 안전하게 받는다.</li><li>네이티브 → 웹: Proxy 패턴 기반 명령형 호출. Reader 블록 안에서 proxy.evaluate로 JS를 실행하고 결과를 받는다.</li></ul><pre>struct SomeWebView: View {<br>    var body: some View {<br>      WebViewReader { proxy in<br>        WebView&lt;SomeBridge&gt;(urlString: url, proxy: proxy) { bridge in<br>          switch bridge {<br>          case .contentReady:<br>            Task { let height = try await proxy.evaluate(.scrollHeight) }<br>          case .uploadCompleted:<br>            print(&quot;업로드 완료&quot;)<br>          }<br>        }<br>      }<br>    }<br>  }</pre><p>기존 레거시보단 나아졌지만, 어찌 보면 복잡해진 구조라고 느낄 수도 있습니다. 그러나 여러 설계 방식을 직접 대입해보고, 팀과 의논하면서 같이 쓰기 좋은 구조를 만들어나가는 과정 자체도 중요하다고 생각했습니다. 완벽한 설계란 없으니까, 계속 고쳐나가면서 더 나은 방식을 찾아 탐구해보려 합니다.</p><p>긴 글 읽어주셔서 감사합니다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d2e4d35369f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SwiftUI에서 WKWebView 통신 재설계 (1)]]></title>
            <link>https://medium.com/@kyuchul2/swiftui%EC%97%90%EC%84%9C-wkwebview-%ED%86%B5%EC%8B%A0-%EC%9E%AC%EC%84%A4%EA%B3%84-1-11dd79f6d70d?source=rss-46a4ba84478------2</link>
            <guid isPermaLink="false">https://medium.com/p/11dd79f6d70d</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[phantom-types]]></category>
            <category><![CDATA[webview]]></category>
            <category><![CDATA[swiftui]]></category>
            <category><![CDATA[ios]]></category>
            <dc:creator><![CDATA[kyuchulkim]]></dc:creator>
            <pubDate>Sat, 11 Apr 2026 08:58:02 GMT</pubDate>
            <atom:updated>2026-04-11T11:05:22.800Z</atom:updated>
            <content:encoded><![CDATA[<h4>Phantom Type으로 웹 → 네이티브 브릿지 이벤트 처리하기</h4><h3>들어가며</h3><p>안녕하세요. 이번엔 재직중인 회사의 SwiftUI 환경에서 WKWebView 통신 구조를 재설계한 경험을 정리해보려고 합니다.</p><p>iOS 앱과 웹페이지 간의 통신은 WKWebView를 통해 구현할 수 있습니다. 웹페이지는 JavaScript Bridge로 iOS 앱에 데이터를 전달하고, iOS 앱은 웹페이지의 JavaScript 함수를 호출 할 수 있습니다.</p><h3>왜 재설계가 필요했나</h3><p>재직중인 회사의 iOS 프로젝트는 네이티브 앱이지만, 많은 화면들을 웹뷰로 사용 중입니다. 웹뷰 구조가 늘어나면서 웹↔네이티브 통신 코드를 재사용하려 했는데, 기존 레거시 웹뷰 구조는 더 많은 피처 개발에 앞서 빠르게 고쳐서 유지보수가 가능한 구조로 변경이 필요했습니다.</p><p>웹페이지 → iOS 앱으로 데이터를 전달할 때는 <strong>WKScriptMessageHandler</strong>프로토콜 메소드인 func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage)를 구현하여 통신합니다.</p><p>그런데 이 메소드 내부에 모든 브릿지 로직이 모이다 보니, 다음과 같은 레거시 이슈가 존재했습니다.</p><pre>struct SwiftUIWebView: UIViewRepresentable {<br>    class Coordinator: NSObject, WKScriptMessageHandler {<br>      var parent: MyWebView<br><br>      func userContentController(_ userContentController: WKUserContentController,<br>                                 didReceive message: WKScriptMessage) {<br>        guard let messageBody = message.body as? String else { return }<br><br>        if messageBody.hasPrefix(&quot;actionA&quot;) {<br>          NotificationCenter.default.post(name: .actionA, object: nil)<br>        } else if messageBody.hasPrefix(&quot;actionB&quot;) {<br>          parent.webview.evaluateJavaScript(&quot;window.someHandler(&#39;\\(jsonString)&#39;)&quot;)<br>        } else if messageBody.hasPrefix(&quot;actionC&quot;) {<br>          NotificationCenter.default.post(name: .actionC, object: url)<br>        } else if messageBody.hasPrefix(&quot;actionD&quot;) {<br>          NotificationCenter.default.post(name: .actionD, object: nil)<br>        } <br>        // ... 수십 개의 if-else 분기가 계속<br>      }<br>    }<br>  }<br>  <br> // 실제 사용하는 화면<br>struct SomeScreen: View {<br>    var body: some View {<br>      SwiftUIWebView(urlString: url)<br>        .onReceive(NotificationCenter.default.publisher(for: .actionA)) { _ in<br>          // 처리<br>        }<br>        .onReceive(NotificationCenter.default.publisher(for: .actionC)) { notification in<br>          guard let url = notification.object as? String else { return }<br>          print(urlString)<br>        }<br>        .onReceive(NotificationCenter.default.publisher(for: .actionD)) { _ in<br>          // 처리<br>        }<br>        // ... 받는 쪽에도 계속 나열<br>    }<br>  }</pre><ol><li><strong>거대한 if-else 분기: </strong>하나의 메서드에 모든 브릿지 로직이 쏟아져 있음</li><li><strong>NotificationCenter로 느슨하게 연결된 통신: </strong>웹뷰에서 이벤트를 방출하면, 전혀 다른 화면이 onReceive로 받아서 처리<br>- 컴파일 타임에 누가 어떤 이벤트를 쓰는지 추적 불가<br>- 같은 이름의 Notification을 여러 화면에서 받으면 의도치 않은 사이드 이펙트</li><li><strong>화면별 커스터마이징 불가</strong>: 어떤 화면에서 어떤 브릿지를 쓰는지 알 수 없음</li><li><strong>재사용 불가</strong></li></ol><p>특히 2번이 가장 큰 문제였습니다. 웹뷰가 이벤트를 던지면 어딘가에서 받아주겠지 식의 구조라, 새 화면을 추가할 때 어떤 Notification을 구독해야 하는지 문서나 다른 화면을 뒤져봐야 했습니다.</p><p>이런 구조를 <strong>완벽하진 않더라고 빠르게 SwiftUI의 선언적 스타일에 맞게 재설계</strong>하고 싶었습니다.</p><h3>1차 구현: 전체 Bridge를 enum으로 정의 + View별 .onBridgeEvent 구독</h3><p>기존 웹뷰는 &quot;actionA&quot;.hasPrefix(...)처럼 Bridge Action 문자열을 하드코딩해서 매칭하고 있었습니다.</p><p>먼저 enum으로 정의해 타입 안전하게 만들고, 받는 쪽은 SwiftUI의 체이닝 modifier 방식으로 변경했습니다.</p><h4><strong>SwiftUI의 Progressive Disclosure 패턴</strong></h4><p>.padding(), .background()처럼 필수 파라미터는 init에, 선택적 설정은 modifier 체이닝으로 빼는 SwiftUI 네이티브 API 방식을 채택했습니다. <a href="https://developer.apple.com/videos/play/wwdc2022/110353/">(WWDC22 “Design protocol interfaces in Swift”)</a></p><pre>// 브릿지 정의<br>  enum BridgeEvent: String {<br>    case actionA<br>    case actionB<br>    case actionC<br>    // ...<br>  }<br>  <br>// 사용부<br>  SwiftUIWebView(url: url)<br>    .onBridgeEvent(.actionA) { _ in dismiss() }<br>    .onBridgeEvent(.actionC) { value in handleC(value) }</pre><p>1차적으론 다음과 같은 해결이 되었습니다.</p><ol><li><strong>Bridge Action 문자열 하드코딩 제거</strong></li><li><strong>무분별한 NotificationCenter 제거</strong></li><li>화면이 필요한 브릿지만 선언적으로 구독</li></ol><p>그러나 다음과 같은 한계도 존재했습니다.</p><ol><li><strong>페이로드 타입이 String으로 통일되어 호출부에서 직접 파싱</strong></li><li><strong>모든 case가 모든 화면에 노출됨</strong></li></ol><h4>페이로드 타입이 String으로 통일되어 호출부에서 직접 파싱</h4><pre>struct SwiftUIWebView: UIViewRepresentable {<br>    // ...<br>    fileprivate var actionHandlers: [PWBridgeEvent: (String?) -&gt; Void] = [:]<br><br>    func onBridgeEvent(<br>      _ event: PWBridgeEvent,<br>      action: @escaping (String?) -&gt; Void<br>    ) -&gt; Self {<br>      var view = self<br>      view.actionHandlers[event] = action<br>      return view<br>    }<br>  }<br><br>// Coordinator WKScriptMessageHandler 프로토콜 메서드 구현<br>func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {<br>    guard<br>      message.name == &quot;actionHandler&quot;,<br>      let messageBody = message.body as? String,<br>      let event = PWBridgeEvent(messageBody: messageBody)<br>    else { return }<br><br>    actionHandlers[event]?(messageBody)<br>  }</pre><ul><li>들어온 메시지의 Bridge action에 따라 서로 다른 핸들러를 실행해야 했기에, Key 고유성이 <strong>“이벤트 하나 = 핸들러 하나”</strong>를 보장해주는 <strong>딕셔너리(</strong><strong>[BridgeEvent:(String?) -&gt; Void])</strong>를 저장소로 활용했습니다.</li><li>modifier 호출 시 view.handlers[event] = action 한 줄로 등록이 끝나고, 체이닝 modifier 패턴과도 자연스럽게 맞물렸습니다.</li><li>문제는 <strong>Swift 딕셔너리는 Value 타입이 하나로 고정되어야 한다는 점</strong>이었습니다. <strong>브릿지마다 페이로드가 다른데(Void, URL, 구조체…) 한 컨테이너에 담으려면 공통분모가 필요</strong>했고, 페이워치는 웹 → 네이티브 페이로드를 문자열로 내려주는 규약을 가지고 있어 String으로 통일할 수밖에 없었습니다.</li></ul><pre>SwiftUIWebView(urlString: url)<br>    .onBridgeEvent(.someBridge) { value in<br>      guard let data = value?.data(using: .utf8),<br>            let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],<br>            let foo = json[&quot;foo&quot;] as? String,<br>            let bar = json[&quot;bar&quot;] as? Int<br>      else { return }<br>      handleSomeBridge(foo: foo, bar: bar)<br>    }</pre><ul><li>문제는 파싱 책임이 외부 호출부에 떠넘겨졌다는 점이었습니다. Bridge action은 enum으로 타입 안전해졌지만, 페이로드 파싱은 매번 호출부가 직접 써야 했습니다.</li><li>같은 브릿지가 여러 화면에서 쓰이면 이 파싱이 뷰마다 복사되고, 웹 스펙이 바뀌면 모든 구독 지점을 고쳐야 했습니다.</li><li>파싱 책임을 브릿지 정의 쪽으로 옮겨 타입 안전한 이벤트 모델이 필요했습니다.</li></ul><h4>모든 case가 모든 화면에 노출됨</h4><pre>enum BridgeEvent: String {<br>    case actionA<br>    case actionB<br>    case actionC<br>    // ... 수십개의 브릿지 존재<br>  }</pre><ul><li>BridgeEvent가 단일 enum이라 어느 화면에서든 모든 브릿지 case가 자동완성에 노출되었습니다. (결제 화면에서 서류 제출 브릿지가 보이는 식)</li><li>클라이언트가 자신이 사용하지 않는 멤버에 강제로 의존하는 ISP(인터페이스 분리 원칙) 위반이라고 생각 했습니다.</li></ul><h3>Phantom Type으로 문제 해결하기</h3><p>앞서 본 두 한계를 풀려면 브릿지가 자기 페이로드 타입을 직접 선언하고, 호출부는 이미 구체 타입으로 변환된 값을 그대로 받는 구조가 필요했습니다.</p><p>이를 실현하기 위해 <strong>브릿지마다 다른 페이로드 타입을 컴파일러가 추적할 수 있는 구조</strong>가 필요했고, <strong>Phantom Type</strong>을 활용했습니다.</p><h4>Phantom Type</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2kyD7NtQJ-NjUqmn3R1uJQ.png" /></figure><p><strong>Phantom Type</strong>은 <strong>제네릭 타입 매개변수를 실제 저장하지 않으면서도 컴파일 타임 타입 체크에만 사용하는 기법</strong> 입니다.</p><pre>// ① 모든 단위 타입이 따라야 할 공통 프로토콜<br>protocol Distance {}<br><br>// ② 프로토콜을 채택한 단위 타입들<br>enum Kilometers: Distance {}<br>enum Miles: Distance {}<br><br>// ③ Phantom Type — U는 stored property에 등장하지 않음<br>struct Unit&lt;U: Distance&gt; {<br>  let length: Double // ← U 타입의 값은 어디에도 저장되지 않음<br>}<br><br>// ④ 사용 — 같은 구조(Double 하나)지만 U 자리의 타입이 달라 다른 타입<br>let km = Unit&lt;Kilometers&gt;(length: 10)   // 타입: Unit&lt;Kilometers&gt;<br>let mi = Unit&lt;Miles&gt;(length: 10)        // 타입: Unit&lt;Miles&gt;</pre><ul><li>Distance 프로토콜은 Unit 내부에서 실제 값으로 저장되지도 않고, 요구사항이 없어서 Kilometers/Miles에 기능을 부여하지도 않습니다. 오직 <strong>&quot;이타입이 길이 단위 계열이다&quot;</strong>를 컴파일러에게 표시하는 역할만 합니다.</li><li>Unit&lt;U&gt;는 내부에 Double 하나만 저장하지만, 컴파일러는 Unit&lt;Kilometers&gt;와 Unit&lt;Miles&gt;를 완전히 다른 타입으로 취급합니다. <strong>(단위가 다른 두 값이 섞이는 실수를 컴파일 단계에서 차단)</strong></li><li>한마디로 Phantom Type의 중요한 핵심은 <strong>“같은 구조, 다른 타입”</strong> 입니다. (예시 코드와 설명은 <a href="https://minsone.github.io/programming/swift-phantom-type">민소네님의 글</a>을 인용하여 사용했습니다.)</li></ul><h3>2차 구현: Phantom Type + 화면별 Bridge</h3><h3>Phantom Type을 WebView Bridge 구조에 대입</h3><p>위에서 Unit&lt;U&gt;가 km/mi를 타입으로 구분했던 것처럼, WebView&lt;Bridge&gt;처럼 <strong>화면별 브릿지 계열을 타입으로 구분할 수 있습니다.</strong></p><p><strong>각 화면이 자기 전용 Bridge enum을 정의</strong>하고, WebView의 제네릭 파라미터로 활용 되도록 구성 했습니다.</p><h4>모든 Bridge enum이 따라야 할 공통 프로토콜</h4><pre>// 브릿지 계약 — 각 Bridge enum이 채택<br>protocol BridgeParsable {<br>	// parse는 웹에서 내려온 action 이름과 parameter 문자열을 받아, 자기 자신(구체 Bridge case)으로 변환하는 역할<br>  static func parse(action: String, parameter: String?) -&gt; Self?<br>}</pre><ul><li>Phantom Type 예시의 Distance 프로토콜 역할</li></ul><h4>BridgeParsable을 채택한 화면별 Bridge enum</h4><pre>// 화면 별 브릿지<br>enum Bridge: BridgeParsable {<br>  case foo<br>  case bar(transactionId: String, goodsName: String)<br><br>  static func parse(action: String, parameter: String?) -&gt; Bridge? {<br>    switch action {<br>    case &quot;foo&quot;:<br>      return .foo<br><br>    case &quot;bar&quot;:<br>      guard let data = parameter?.data(using: .utf8),<br>            let dictionary = try? JSONSerialization.jsonObject(with: data) as? [String: Any],<br>            let transactionId = body[&quot;transactionId&quot;] as? String,<br>            let goodsName = body[&quot;goodsName&quot;] as? String<br>      else { return nil }<br>      return .bar(transactionId: transactionId, goodsName: goodsName)<br>    }<br>  }<br>}<br>  <br>// 모든 웹뷰가 공통으로 사용하는 브릿지<br>enum CommonBridge: BridgeParsable {<br>  case closeWebView<br>  ...<br>  ...<br>}</pre><ul><li>각 웹뷰 화면 별로 브릿지를 구성하도록 했고, 브릿지마다 다른 페이로드 타입이 enum 연관값으로 표현되도록 했습니다.</li><li>더불어 모든 화면이 공통으로 사용하는 브릿지는 CommonBridge를 별도 enum으로 정의 했습니다.</li><li>Phantom Type 예시의 Distance을 채택한 Kilometers, Miles 타입 역할</li></ul><h4>Bridge를 WebView의 제네릭 파라미터로 사용</h4><pre>// 화면별 브릿지(Bridge)와 공통 브릿지(CommonBridge)를 하나로 묶는 wrapping enum.<br>// `PWWebView&lt;Bridge&gt;`의 `onBridge` 클로저가 받는 타입.<br>enum BridgeEvent&lt;Bridge: BridgeParsable&gt; {<br>  case common(CommonBridge)<br>  case screen(Bridge)<br>}<br><br>// Phantom Type — Bridge는 stored property에 등장하지 않음<br>struct WebView&lt;Bridge: BridgeParsable&gt;: UIViewRepresentable {<br>  private let url: String<br>  private let onBridge: (BridgeEvent&lt;Bridge&gt;) -&gt; Void // ← Bridge 타입의 값은 어디에도 저장되지 않음<br>}<br><br>// Coordinator WKScriptMessageHandler<br>func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {<br>	guard let raw = message.body as? String else { return }<br>	<br>	// 모든 웹뷰가 공통으로 사용하는 브릿지 먼저 파싱<br>	if let bridge = CommonBridge.parse(action: action, parameter: parameter) {<br>		parent.onBridge(bridge)<br>	}<br>	<br>	// Bridge는 stored property에 없지만, static 메서드는 호출 가능<br>	// Bridge: BridgeParsable 제약이 컴파일러에게 &quot;Bridge가 무엇이든 parse는 반드시 있다&quot;를 보장<br>	if let bridge = Bridge.parse(action: action, parameter: parameter) {<br>		parent.onBridge(bridge)<br>	}<br>}<br><br>// 화면 A<br>WebView&lt;FooBridge&gt;(url: url) { event in<br>  switch event {<br>  case .common(.closeWebView): ...<br>  case .screen(.foo): ...<br>  case .screen(.bar(let count)): ...<br>  }<br>}<br><br>// 화면 B<br>WebView&lt;BazBridge&gt;(url: url) { event in<br>  switch event {<br>  case .common(.closeWebView): ...<br>  case .screen(.baz(let title)): ...<br>  }<br>}</pre><ul><li>각 화면은 자기 전용 Bridge enum을 정의하고, WebView의 타입 파라미터로 지정하면 됩니다.</li><li>두 화면의 WebView는 내부 구조가 동일하지만, 컴파일러는 WebView&lt;FooBridge&gt;와 WebView&lt;BazBridge&gt;를 완전히 다른 타입으로 취급합니다. <strong>(화면 A의 클로저에 화면 B의 case를 매칭하려 하면 컴파일 에러 발생)</strong></li><li>Phantom Type 예시의 struct Unit&lt;U: Distance&gt; 역할을 WebView&lt;Bridge&gt;가 수행</li></ul><h4>Declarative API 원칙을 살리며 사용</h4><pre>public struct ForEach&lt;Data, ID, Content&gt;: View<br>    where Data: RandomAccessCollection, ID: Hashable, Content: View</pre><ul><li>SwiftUI 네이티브 API를 떠올려보면, ForEach, List, VStack 모두 내부적으로 제네릭 파라미터를 가지지만 호출부에는 &lt;&gt;가 등장하지 않습니다.</li><li>하지만 앞서 본 WebView&lt;FooBridge&gt;(url: url) { ... }에는 &lt;FooBridge&gt;가 그대로 드러나 있습니다.</li></ul><pre>struct SomeWebView: View {<br>  enum Bridge: BridgeParsable {<br>    case foo<br>    case bar(count: Int)<br><br>    static func parse(action: String, parameter: String?) -&gt; Bridge? { ... }<br>  }<br><br>  var body: some View {<br>    WebView&lt;Bridge&gt;(url: &quot;&lt;https://example.com&gt;&quot;) { event in<br>      switch event {<br>      case .common(.closeWebView):<br>        print(&quot;close&quot;)<br>      case .common(.startWebBrowser(let url)):<br>        print(&quot;open: \\(url)&quot;)<br>      case .screen(.foo):<br>        print(&quot;foo&quot;)<br>      case .screen(.bar(let count)):<br>        print(&quot;bar count: \\(count)&quot;)<br>      }<br>    }<br>  }<br>}<br><br>// 실제 사용처<br>SomeWebView()</pre><ul><li>제네릭이 노출되면 호출부가 복잡해져 선언형 사용성이 떨어집니다. Declarative API 원칙을 따르기 위해 화면별 Wrapper View로 한 번 더 감쌌습니다.</li><li>Wrapper View 내부에서만 WebView&lt;Bridge&gt; 제네릭을 다루고, 외부 호출부에는 도메인 이름을 가진 웹뷰만 노출됩니다.</li></ul><h3>단계별 변화 정리</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CAnA5Ej3v0PjSFPo44W5QQ.png" /></figure><ul><li><strong>기존 웹뷰:</strong> hasPrefix(“foo”) 같은 문자열 매칭과 NotificationCenter로 화면 간 브릿지가 느슨하게 얽혀 있음. 이벤트 발행과 수신 지점이 컴파일러에게 보이지 않아 흐름 추적이 어려움</li><li><strong>1차 리팩토링:</strong> 전역 Bridge enum과 체이닝 modifier로 문자열 하드코딩을 제거하고 선언적 구독을 얻음. 하지만 enum이 모든 화면의 케이스를 담고 있어 scope 분리가 안 되고, 페이로드가 String?으로 통일되어 호출부가 직접 파싱</li><li><strong>2차 리팩토링:</strong> WebView&lt;Bridge&gt;의 Phantom Type이 화면별로 Bridge 계열을 분리하고, 각 Bridge enum의 parse가 파싱 책임을 가져가면서 두 한계가 해결</li></ul><h4>참고자료</h4><ul><li><a href="https://minsone.github.io/programming/swift-phantom-type">https://minsone.github.io/programming/swift-phantom-type</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=11dd79f6d70d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Claude Code, 나만의 하네스 엔지니어링으로 iOS 앱 50%을 리팩토링하기]]></title>
            <link>https://medium.com/@kyuchul2/claude-code-%EB%82%98%EB%A7%8C%EC%9D%98-%ED%95%98%EB%84%A4%EC%8A%A4-%EC%97%94%EC%A7%80%EB%8B%88%EC%96%B4%EB%A7%81%EC%9C%BC%EB%A1%9C-ios-%EC%95%B1-50-%EC%9D%84-%EB%A6%AC%ED%8C%A9%ED%86%A0%EB%A7%81%ED%95%98%EA%B8%B0-a96c4580e522?source=rss-46a4ba84478------2</link>
            <guid isPermaLink="false">https://medium.com/p/a96c4580e522</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[kyuchulkim]]></dc:creator>
            <pubDate>Fri, 10 Apr 2026 01:43:54 GMT</pubDate>
            <atom:updated>2026-04-11T11:26:18.141Z</atom:updated>
            <content:encoded><![CDATA[<h4>리팩토링·테스트·리뷰하는 AI 팀원 만들어 쓰기</h4><h3>들어가며</h3><p>안녕하세요, 이번 글에선 저만의 기초적인 방식으로 Claude Code를 활용해서 재직중인 회사의 iOS 앱의 50% 이상을 다시 만든 이야기를 해보려고 합니다.</p><h3>왜 리팩토링이 필요했나</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UB1ubz_ABGEyozSD8eeUOA.png" /></figure><p>재직중인 회사의 iOS 앱은 빠른 기능 출시를 우선하다 보니 다음과 같은 문제가 누적되어 있었습니다.</p><ul><li>화면 간 깊은 의존성과 네비게이션 로직 부재: 이전 글<a href="https://medium.com/@kyuchul2/ios-%ED%99%94%EB%A9%B4%EC%A0%84%ED%99%98-%EB%A6%AC%ED%8C%A9%ED%86%A0%EB%A7%81-%EA%B8%B0%EB%A1%9D-1-navigation-di-%EA%B5%AC%EC%A1%B0-%EC%84%A0%ED%83%9D-%EA%B3%BC%EC%A0%95-6f1de9b6b9ba"> <strong>iOS 화면전환 리팩토링 기록</strong></a>에서 다룬 것처럼, 화면들이 서로의 내부를 알고 있는 구조였습니다.</li><li>MVC 구조의 잔재: View와 비즈니스 로직이 강하게 결합되어 있어 단위 테스트 작성 자체가 불가능했습니다.</li></ul><p>이런 문제들이 쌓이면서 자잘한 iOS 인입 이슈는 끊이지 않았고, 그중에서도 가장 많은 이슈가 발생한 곳은 회원가입/로그인과 핵심 기능인 충전/전환 이였습니다. 그렇기에<strong> 리팩토링은 선택이 아닌 필수</strong>였습니다.</p><p><strong>리팩토링 작업은 상당수는 방대하면서도 일정한 프로젝트 규칙 패턴의 연속</strong>이라고 생각했습니다. 사람이 손으로 하기엔 지치고, 그렇다고 건너뛸 수도 없는 작업들. 이런 영역이야말로 AI를 잘 활용해보면 어떨까 생각이 들었습니다.</p><h4>How do you make the most of AI?</h4><p>AI는 코드를 작성하고, 테스트를 생성하고, 버그를 찾습니다. 사람보다 빠르고, 지치지 않습니다.</p><p>이러한 상황에서 개발자에게 중요한 건 코드 한 줄 한 줄을 고민하는 것이 아니라, AI에게 초기 계획을 잘 설정하고, 중간에 올바르게 개입하고, 최종 결과를 검증하는 기준 설정자로서의 역량이라고 봤습니다.</p><p>그러기 위해선 <strong>AI가 제대로 일하게 만드는 실행 환경</strong>과 <strong>설계된 흐름대로 AI가 진행되도록 하는 프로세스</strong>가 중요하다고 생각했습니다.</p><h3>AI가 제대로 일하게 만드는 실행 환경 구성</h3><h3>Rules로 프로젝트 규칙 세분화하기</h3><p><strong>.claude/rules/</strong> 디렉토리를 사용하여 프로젝트 지침을 여러 파일로 구성할 수 있었습니다. 관심사별로 세분화된 iOS 프로젝트 규칙을 정의하면서 AI가 맥락을 놓치거나, 최소한의 지침을 따르지 않는 이슈를 방지했습니다.</p><pre>.claude/rules/<br>  ├── ios-architecture-guide.md       # 모듈 구조, 의존성 규칙<br>  ├── ios-coding-patterns.md          # 레이어별 코딩 패턴 (UseCase, Repository, API, DTO)<br>  ├── ios-coordinator-guide.md        # 네비게이션 패턴<br>  ├── ios-design-system-guide.md      # 디자인시스템 컴포넌트 설계 원칙<br>  ├── ios-view-guide.md               # SwiftUI View, UIKit UIViewController 패턴<br>  ├── ios-viewModel-guide.md          # ViewModel 패턴<br>  ...<br>  ...<br>  ...</pre><ul><li>rule들을 처음부터 한번에 만든 건 아닙니다. 개발을 진행하면서 AI가 놓치는 패턴이 보이면 규칙을 추가하고, 불필요해진 내용은 삭제하고, 더 나은 방식을 발견하면 업데이트 했습니다.</li><li>이 과정을 반복하면서 Rules는 단순한 설정 파일이 아니라, 프로젝트의 아키텍처와 개발 히스토리가 축적된 자산이라는 생각을 하며 관리했습니다.</li></ul><h4>rule 파일 속 경로별 규칙</h4><p>Rule은 매 세션마다 로드됩니다. 하지만 모든 규칙이 항상 필요한 건 아니였습니다. (ViewModel을 수정하는데 DesignSystem 가이드가 로드 될 필요 X)</p><pre>  # ios-view-guide.md<br>  ---<br>  paths:<br>    - &quot;**/*View.swift&quot;<br>    - &quot;**/*View/**/*.swift&quot;<br>  ---<br><br>  # ios-coordinator-guide.md<br>  ---<br>  paths:<br>    - &quot;**/*Coordinator*.swift&quot;<br>    - &quot;**/*Route.swift&quot;<br>  ---</pre><ul><li>architecture-guide.md나 coding-patterns.md처럼 프로젝트 전반에 적용되는 규칙은 paths 없이 항상 로드되도록 두고, View나 Coordinator처럼 특정 레이어에만 해당하는 규칙은 paths로 범위를 제한하여 불필요한 컨텍스트 로드를 줄이도록 했습니다.</li></ul><h3>Skills로 작업별 전문 지식 분리하기</h3><p>항상 컨텍스트에 올려둘 필요 없는, 특정 작업을 수행할 때만 필요한 iOS 관련 작업을 Skills로 분리 했습니다.</p><pre>.claude/skills/<br>  ├── ios-review/                  # 코드 리뷰 Skill<br>  │   ├── SKILL.md<br>  │   └── scripts/get-diff.sh<br>  ├── swift-tdd/                   # TDD 테스트 Skill<br>  │   ├── SKILL.md<br>  │   └── references/<br>  │       ├── swift-testing.md<br>  │       ├── mocking-strategies.md<br>  │       └── ...<br>  ├── swift-concurrency/           # Swift Concurrency 관련 Skill<br>  │   ├── SKILL.md<br>  │   └── references/           <br>  │       ├── async-await.md<br>  │       ├── actors.md<br>  │       ├── sendable.md<br>  │       ├── ...<br>  ├── swiftui/                     # SwiftUI 관련 Skill<br>  │   ├── SKILL.md<br>  │   └── references/             <br>  │       ├── state-management.md<br>  │       ├── performance.md<br>  │       ├── ...<br>  ├── swift-clean-code/            # Swift SOLID 원칙 + 함수형 프로그래밍 <br>  │   ├── SKILL.md<br>  │   └── references/<br>  │       ├── srp.md<br>  │       ├── ocp.md<br>  │       ├── lsp.md<br>  │       ├── ...<br>  └── fastlane-ci-cd/               # CI/CD 파이프라인<br>      └── SKILL.md<br>  ...<br>  ...<br>  ...</pre><ul><li>예를 들어 특정 화면에서 Race Condition 발생 위험이 있거나, 기존 레거시 GCD/Combine 환경을 Swift Concurrency로 마이그레이션해야 할 때 /swift-concurrency를 호출하면 async/await, Actor 등 관련 레퍼런스를 바탕으로 동작할 수 있었습니다.</li><li>이후 이러한 Skills는 아래에서 소개할 에이전트들이 무엇을 알고, 어떻게 동작할지를 정의하는 기반이 됩니다.</li></ul><h4>Skills에 Progressive Disclosure 패턴 적용하기</h4><p>Skills도 Rules처럼 한 파일에 모든 내용을 담으면 컨텍스트가 낭비됩니다. 이를 해결하기 위해 SKILL.md에는 개요와 판단 기준만 두고, 상세 내용은 references/로 분리하는 <strong>Progressive Disclosure</strong> 패턴을 적용했습니다.</p><pre>swift-clean-code/<br>  ├── SKILL.md              # 개요 + 어떤 상황에서 어떤 레퍼런스를 읽을지 가이드<br>  └── references/<br>      ├── srp.md<br>      ├── ocp.md<br>      ├── lsp.md<br>      ├── ...</pre><ul><li>또한 레퍼런스 문서 외에 scripts/ 디렉토리를 통해 셸 스크립트를 포함시킬 수도 있습니다. ios-review Skill의 경우 scripts/get-diff.sh를 통해 변경된 코드의 diff를 자동으로 추출한 뒤 리뷰를 수행하도록 구성했습니다.</li></ul><h4>Workflow Decision Tree</h4><p>SKILL.md 안에는 <strong>Workflow Decision Tree</strong>를 작성하여, AI가 상황에 맞는 레퍼런스만 찾아 읽도록 했습니다.</p><pre>Workflow Decision Tree<br>  <br>  1) 클래스의 책임이 불명확할 때<br>     → &quot;변경 이유가 2개 이상이면 분리 필요&quot;<br>     → Read references/srp.md<br><br>  2) 새 기능 추가 시 기존 코드를 수정해야 할 때<br>     → &quot;switch/if-else가 계속 늘어나는가?&quot;<br>     -&gt; &quot;protocol/interface + 구현체로 확장 가능하게&quot;<br>     → Read references/ocp.md</pre><ul><li>AI는 SKILL.md만 먼저 읽고, 현재 작업에 해당하는 레퍼런스만 선택적으로 로드합니다. 10개 이상의 레퍼런스를 가진 skill도 매번 전부 읽지 않고, 필요한 2~3개만 참조하게 되는 구조입니다.</li></ul><h3>SubAgent로 iOS 팀원 만들기</h3><p>Skills를 직접 호출해서 사용할 수도 있지만, Skills를 만든 주된 목적은 에이전트가 할 일을 정의해두기 위해서였습니다.</p><p>리팩토링할 때 어떤 지식을 참고해야 하는지, 테스트를 작성할 때 어떤 패턴을 따라야 하는지 이 기준을 Skills에 적어두고, <strong>에이전트가 이를 읽고 동작하도록 구성</strong>했습니다.</p><h4>리팩토링 업무를 맡을 3명의 후임 SubAgent 팀원</h4><pre>.claude/agents/<br>  ├── ios-refactoring-specialist.md   # 리팩토링 전문가<br>  ├── ios-tester.md                   # TDD 테스트 전문가<br>  └── ios-code-reviewer.md            # 코드 리뷰 전문가</pre><ul><li><strong>리팩토링 전문가</strong>: 에이전트는 구조 분석 → 의존성 분석 → 비즈니스 로직 추출 → 데이터 흐름 추적 → 마이그레이션 로드맵 설계 → 문서 작성까지 6단계 Phase로 진행됩니다. <strong>각 Phase마다 필요한 Skill 레퍼런스만 골라 참조</strong>하며, 변경 계획은 플랜 문서로 저장되어 사람이 승인한 뒤 실행됩니다.</li><li><strong>테스트 전문가</strong>: swift-tdd Skill을 기반으로 리팩토링된 코드에 대해 단위 테스트를 작성하고 실행까지 수행합니다.</li><li><strong>코드 리뷰 전문가</strong>: ios-review Skill을 기반으로 변경된 코드를 검토하여 CRITICAL/HIGH/MEDIUM/LOW 등의 등급 별 이슈를 추출합니다. 리뷰 과정에서 아키텍처나 동시성 관련 이슈가 발견되면 해당 Skill 레퍼런스를 추가로 참조합니다.</li></ul><h4>Skills와 Agents는 어떻게 연결되는가?</h4><p>에이전트는 작업을 수행할 때 Skills의 레퍼런스 파일을 필요한 만큼만 Read로 로드하여 참조하도록 했습니다. 에이전트 프롬프트에 Skill 도구로 /skill-name호출을 명시 하거나, Read로 스킬의 references/ 파일을 필요 시 로드하도록 했습니다.</p><pre>  에이전트 (누가)           →  Skills (어떻게)              →  Rules (어떤 규칙으로)<br>       │                          │                              │<br>  ios-refactoring-specialist.md   swift-concurrency/             ios-architecture-guide.md<br>                                  └── references/                ios-coding-patterns.md<br>                                      ├── actors.md<br>                                      └── async-await.md</pre><h4>Agent에 페르소나 부여하기</h4><p>에이전트는 Skills와 달리 <strong>“누가 하는가”</strong>를 정의합니다. 같은 코드를 보더라도 리팩토링 에이전트와 코드 리뷰 에이전트는 다른 관점에서 접근해야 합니다.</p><p>이를 위해 각 에이전트마다 전문가 페르소나를 설정해두면 어떨까 생각이 들었고, 이를 통해 Claude가 역할에 맞는 판단과 행동을 하도록 했습니다.</p><pre>ios-refactoring-specialist<br>  <br>Persona<br><br>이름: 김규철 | 경력: 12년 (iOS 소프트웨어 아키텍트)<br><br>  약력<br>  - 국내 대형 핀테크 기업 Core팀 (5년) — 200만 MAU 금융 앱의 모놀리식 구조를<br>    15개 모듈로 분리하는 Clean Architecture 마이그레이션을 리드.<br>    빌드 시간을 12분에서 4분으로 단축.<br>  - 국내 금융 서비스 기업 iOS팀 (7년) — 7년된 Objective-C/Swift 혼합 코드베이스를<br>    점진적으로 Swift 전환. 운영 장애 없이 2년에 걸쳐 마이그레이션 완료.<br><br>  성격<br>  - 분석적이고 체계적. &quot;리팩토링의 첫 번째 규칙은 기존 동작을 보존하는 것이다&quot;라고 믿는다.<br>  - 코드를 먼저 깊이 이해한 후에만 변경을 제안한다.<br>  - 과감한 대규모 리팩토링보다 안전한 점진적 개선을 선호한다.<br>  - 금요일 오후에 리팩토링 PR을 올리는 사람을 이해하지 못한다.</pre><h3>설계된 흐름대로 AI가 진행되도록 하는 프로세스</h3><h3>Command로 리팩토링 파이프라인 구성하기</h3><p>앞서 만든 3명의 에이전트를 개별적으로 호출할 수도 있지만, 리팩토링 → 테스트 → 리뷰라는 흐름은 매번 동일합니다.</p><p>이 반복되는 워크플로우를 ClaudeCode의 Command 기능으로 묶어 파이프라인으로 구성해 순차적 작업 흐름이 이루지도록 했습니다.</p><pre>/ios-refactor &quot;SignInView에서 네이버 로그인 SDK 의존성 분리&quot;<br><br>    ┌─────────────────────────────────────┐<br>    │  Phase 1: 리팩토링 전문가 에이전트 호출    │<br>    │  → 의존성 추적, 로드맵 생성, 리팩토링 실행  │<br>    │  → 리팩토링 문서 작성                   │<br>    │  → 사용자 검토 및 승인                  │<br>    ├─────────────────────────────────────┤<br>    │  Phase 2: 테스트 전문가 에이전트 호출      │<br>    │  → 리팩토링 문서와 변경된 코드를 기반으로    │<br>    │    단위 테스트 작성 및 실행              │<br>    │  → 사용자 검토 및 승인                  │<br>    ├─────────────────────────────────────┤<br>    │  Phase 3: 코드 리뷰 전문가 에이전트 호출   │<br>    │  → 이슈 추출                          │<br>    │  → CRITICAL/HIGH → 자동 수정 → 빌드 →   │<br>    │    재검토 (피드백 루프)                  │<br>    │  → MEDIUM/LOW → 메인 컨텍스트에 반환     │<br>    │  → 사용자 최종 검토                     │<br>    └─────────────────────────────────────┘</pre><h4>에이전트 팀(Agent Teams)을 사용하지 않은 이유</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2bMFkGpk2OyAfwuKn_8jiw.png" /><figcaption><a href="https://code.claude.com/docs/ko/agent-teams">https://code.claude.com/docs/ko/agent-teams</a></figcaption></figure><ul><li>Subagents는 결과만 메인 에이전트에게 보고하고 서로 대화하지 않습니다.</li><li>Claude Code의 Agent Team 기능은 팀원들이 작업 목록을 공유하고, 요청하며, 서로 직접 통신하여 여러 에이전트가 독립적인 인스턴스로 병렬 실행되도록 할 수 있습니다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z6WV55NjGlKMKJI5QVzYkQ.png" /></figure><p>에이전트팀 기능을 사용하지 않은 큰 이유는 현재 운영 중인 서비스의 코드이기 때문입니다. 즉, 달리는 자동차의 바퀴를 갈아끼우는 작업이라고 생각했습니다. 서비스의 근간이 되는 핵심 플로우를 다시 만든다는 건 그만큼 신중해야 하고 책임이 따른다고 느꼈습니다.</p><p>F1 피트스탑과 같다고 생각했습니다. 레이스 중간에 타이어를 교체하지만, 엔진은 여전히 돌아가고 있고 다시 트랙에 복귀해야합니다.</p><p>오랜 기간 쌓인 레거시에는 코드만 봐서는 알 수 없는 히스토리가 존재하고, 피트 크루의 작은 실수로 레이스를 리타이어해야 하는것처럼 항상 신중해야 한다고 생각했습니다.</p><p>AI가 알 수 없는 <strong>서비스의 맥락과 히스토리를 알고 있는 사람의 중간 개입</strong>이 꼭 필요하다고 판단했습니다.</p><h3>로그인 화면 분해 작업에 적용해보기</h3><h3>로그인 화면의 다양한 레거시 이슈</h3><p>대표적인 예로 로그인 화면은 SDK 의존성, 네트워크 통신, 동시성 문제, 네비게이션, UI, 비즈니스 로직이 모두 얽혀 있는 다양한 이슈를 가지고 있었습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/639/1*TUWO9_pKJ_57uh6h2yVbzw.png" /></figure><ol><li>각 SNS 로그인(네이버, 카카오, 구글, 애플) SDK 호출 로직이 View 내부에 직접 존재</li><li>백엔드와 통신하는 레거시 SwiftyJSON 기반 네트워크 코드가 View에 존재</li><li>위 로직들이 모두 GCD 기반으로 호출되어 Swift 6 strict concurrency 경고/에러 발생</li><li>Coordinator 패턴이 적용되지 않아 View가 View Hierarchy에 남아있는 show/hide 방식의 화면 전환</li><li>디자인 시스템 컴포넌트가 사용되지 않는 레거시 UI 컴포넌트 사용</li></ol><h3>Command 사용해서 리팩토링 진행</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kpu-arLrOaG5D1ykPO_0Ug.png" /></figure><ul><li>커맨드로 리팩토링 → 테스트 → 리뷰가 순차적으로 실행되며, 각 단계 사이에 사용자 검토를 거치도록 하여 리팩토링을 진행 할 수 있었습니다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/925/1*JebiLcxXsUYgzywR1X55Iw.png" /><figcaption>리팩토링 에이전트가 일하는 모습</figcaption></figure><h3>프로젝트 모듈 구조에 맞게 리팩토링</h3><p>입사 후 iOS 프로젝트를 단일 모듈에서 Clean Architecture 기반 멀티 모듈 구조로 확장된 형태로 마이그레이션 했습니다.</p><ul><li>App: 앱 진입점, DI 등록 (Composition Root)</li><li>Features: UI + ViewModel + Coordinator (화면 단위)</li><li>Domain: UseCase, Repository 인터페이스, 비즈니스 로직</li><li>Data: Repository 구현, API, DTO</li><li>Core: 네트워크, 저장소, 공통 인프라</li><li>Shared: 도메인 모델, 유틸리티</li></ul><p>모듈 구조의 의존성은 위에서 아래로 단방향으로 흐릅니다. 이러한 의존성 흐름은 architecture-guide를 통해 AI가 매번 컨텍스트 내에 알고 있도록 설정된 상태로 리팩토링을 진행했습니다.</p><h4>로그인 관련 SDK→ Core 모듈로 이관</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VkqTIvtzx1Y2VVnrSZWx3w.png" /></figure><ul><li>View 내부에 직접 호출되던 SNS SDK들이 각각 Clientable 프로토콜로 추상화되어 Core 모듈로 분리</li></ul><h4>비즈니스 로직은 Domain / Data 모듈로 이관</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*57kiv06BG9SjvyBcnnreaQ.png" /></figure><ul><li>위에서 SNS 로그인 SDK는 Clientable 프로토콜로 추상화되었습니다. SDK와 네트워크 통신 관련 프로토콜이 Repository에 주입되고, Repository를 기반으로 UseCase가 비즈니스 로직을 담당합니다.</li></ul><h4>View와 ViewModel은 Features 모듈에서 Presentation 역할만 담당</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y2ioAusr8XxBSBtTagjK-A.png" /></figure><ul><li>View는 UI 렌더링과 사용자 입력만, ViewModel은 State 관리와 UseCase 호출만 담당합니다. SDK나 네트워크에 대한 어떠한 코드도 Features 레이어에 남아있지 않도록 리팩토링 되었습니다.</li></ul><h4>App 모듈에서 DI 등록</h4><ul><li>App 모듈은 Composition Root로서, 모든 모듈에서 정의한 프로토콜의 구현체를 조립하고 DI 컨테이너에 등록하는 역할을 담당하는데 해당 작업까지 진행됩니다.</li></ul><h3>마치며</h3><p>이러한 AI 리팩토링 프로세스를 통해 회원가입/로그인 관련 화면 25개 이상을 Clean Architecture 모듈 기반으로 다시 만들 수 있었습니다.</p><p>더불어 건강보험 조회, 충전 금액 입력 등 핵심 기능인 충전/전환 플로우의 모든 화면과 비즈니스 로직을 모듈 구조에 맞춰 리팩토링하여 모듈화·컴포넌트화했고, 재활용 가능한 구조로 정리할 수 있었습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/328/1*YIxEdz4NNgOSHjZOCbgyJQ.png" /></figure><p>리팩토링 작업은 들어오는 Feature 개발과 병행하면서, <a href="https://code.claude.com/docs/en/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees">Claude Worktree</a>를 활용해 시간이 날 때마다 점진적으로 진행했습니다.</p><p>최대한 Feature 개발에 영향을 주지 않는 방향으로 병렬 작업을 이어갔고, 그 결과 운영을 멈추지 않고도 iOS 앱의 50% 이상을 새로 만들 수 있었습니다.</p><h4>How do you make the most of AI?</h4><p>AI는 계속 발전하고 있습니다. Claude Code도 지금 이 글을 쓰고 있는 순간에도 새로운 기능이 만들어지고, 새로운 방법론이 등장하고 있습니다. 어제 나온 모델이 내일 더 좋은 모델로 대체됩니다. 어쩌면 지금 이 글도 한 달 뒤에는 쓸모없는 글이 될 가능성이 큽니다.</p><p>하지만 한 가지, AI에게 내가 지금 해결해야 할 일의 맥락과 규칙을 어떻게 전달할 것인가라는 본질적인 질문은 계속 가져가야 한다고 생각했습니다. 그래서 가장 기초가 되는 부분만 적용해 본 것이 이번 리팩토링 작업이었습니다.</p><p>처음에는 AI가 빠르게 발전하는 속도를 따라가지 못한다는 조급함에 새로운 기술을 찾고 적용하기에 급급했습니다. 하지만 지금 드는 생각은, 내가 해결해야 할 일에 맞춰 그 일에 적합한 방법을 찾는 것이 더 중요하다는 것입니다.</p><p>Claude Code는 결국 하나의 AI 도구일 뿐이라는 생각을 가지게 되었습니다. 중요한 건 도구가 아니라, 내 일에 맞는 방법을 찾고 빠르게 해결해 나가는 것이라는 점을 잊지 않아야겠다는 생각으로 이 글을 마칩니다.</p><h4>참고 자료</h4><ul><li><a href="https://code.claude.com/docs/en/overview">https://code.claude.com/docs/en/overview</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a96c4580e522" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AWS Infra로 Jenkins + Fastlane iOS CI/CD 구축하기]]></title>
            <link>https://medium.com/@kyuchul2/aws-infra%EB%A1%9C-jenkins-fastlane-ios-ci-cd-%EA%B5%AC%EC%B6%95%ED%95%98%EA%B8%B0-648dae605c8d?source=rss-46a4ba84478------2</link>
            <guid isPermaLink="false">https://medium.com/p/648dae605c8d</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[jenkins]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[fastlane]]></category>
            <dc:creator><![CDATA[kyuchulkim]]></dc:creator>
            <pubDate>Tue, 20 Jan 2026 09:24:34 GMT</pubDate>
            <atom:updated>2026-01-21T01:37:01.166Z</atom:updated>
            <content:encoded><![CDATA[<h4>8년만에 다시 써보는 Jenkins</h4><h3>들어가며</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xsVuH0BbdHsjLJ3i" /><figcaption>made by GPT</figcaption></figure><p>재직중인 회사의 앱팀에서 진행했던 <strong>모바일</strong> <strong>CI/CD 구축을 위한 구조적 설계</strong>에 관한 이야기를 해보려고 합니다.</p><h3>자동화가 필요하다고 느낀 이유</h3><p>매번 새로운 Feature를 진행할 때마다 배포 버전을 전달 시 모든 과정을 수동으로 진행하고 있었습니다.</p><p>만약 QA 버전이 10개가 넘어간다면 <strong>10번의 동일한 슬랙 메시지</strong>와 <strong>앱 빌드 → 테스트 → 배포</strong>까지의 과정을 수동으로 매번 진행해야 했습니다.</p><p>배포를 진행할 때마다 기다리는 시간이 발생하고, 이 시간 동안 다른 작업에 집중하기 어려웠습니다.</p><h3>CI/CD 아키텍처 개요</h3><p>재직 중인 회사는 AWS 인프라를 다양하게 활용하고 있으며, 형상 관리의 경우 AWS CodeCommit을 사용하고 있습니다.</p><p>이러한 환경을 기반으로 다음과 같은 CI/CD 구조를 설계했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wwHfOry74GRl5v0y.png" /><figcaption>다양한 AWS 서비스 사용해보기</figcaption></figure><ol><li><strong>CodeCommit</strong> — PR 생성/Push/Merge 이벤트 발생</li><li><strong>EventBridge</strong> — 이벤트 감지 및 필터링</li><li><strong>Lambda</strong> — Jenkins 트리거 (브랜치, 이벤트 타입 전달)</li><li><strong>Jenkins (ECS)</strong> — CI 서버, Mac mini Agent에 작업 할당</li><li><strong>Fastlane (Mac mini Agent)</strong> — 빌드 + 테스트 + 배포</li><li><strong>TestFlight + (Slack + Jira)</strong> — QA 빌드 업로드 + 빌드 결과 알림</li></ol><p><strong><em>왜 Jenkins인가?</em></strong></p><p>CodeCommit은 GitHub Actions, GitLab CI 같은 자체 CI/CD를 제공하지 않습니다.</p><p>AWS의 CodeBuild/CodePipeline이 있지만, iOS 빌드를 위해선 MacOS가 필요한데, <strong><em>EC2 Mac 인스턴스 빌드 가격</em></strong>이 높기 때문에 사용을 고려하지 않았습니다. 💸</p><p>따라서 <strong>Mac mini 물리 서버를 Jenkins Node Agent로 연결하여 iOS 빌드 환경을 구축</strong>했습니다.</p><h3>Jenkins CI 서버 구성</h3><h4>Jenkins CI 서버 — 왜 ECS인가?</h4><p>처음에는 EC2 서버에 Jenkins Docker를 직접 구성해서 운영하려고 했습니다.</p><p>그러나 인프라팀에 CI 인프라 구성을 요청드리면서 EC2에 올린 Docker를 관리 자동화 할 수 있는 <strong>ECS를 권장</strong>받았습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ru4x4ecRmL0XclIV" /></figure><p>ECS(Elastic Container Service)는 AWS에서 컨테이너의 생성과 종료, 자동 배치 및 복제, 로드 밸런싱, 클러스터링, 장애 복구, 스케줄링 등의 역할을 수행해 주는 <strong>오케스트레이선 도구</strong> 입니다.</p><p>EC2가 아파트라면 ECS를 통해 아파트를 관리사무소에서 관리할 수 있다라고 비유 할 수 있었습니다.</p><p>ECS의 핵심 장점을 한마디로 정의하면 <strong>“서버를 직접 만질 일이 거의 없어진다” 라는 것 입니다.</strong> 아래는 인프라 교육을 받으며 정리해본 직관적으로 보이는 ECS 도입 이유 입니다.</p><p><strong><em>ECS 도입 이유</em></strong></p><ul><li><strong>컨테이너 자동 관리:</strong> ecs로 관리하게 되면 Docker 컨테이너 상태를 자동으로 모니터링하고, 문제 발생 시 자동 복구가 가능</li><li><strong>AWS 리소스 연동 용이:</strong> CloudWatch, EFS 등 AWS 서비스와 간편하게 연결이 가능</li><li><strong>모니터링 부담 제거:</strong> EC2에서는 로그 확인을 위해 터미널 접속, CPU/메모리 사용률 직접 조회가 필요하지만, ECS는 AWS 콘솔에서 바로 확인 가능</li><li><strong>빌드 로그 관리 불필요:</strong> EC2는 빌드 로그가 계속 쌓여 디스크가 차는 문제가 발생하지만, ECS는 로그가 CloudWatch로 전송되어 이 문제가 사라짐</li><li><strong>스파이크 대응:</strong> 빌드 작업은 리소스를 많이 사용하는데, ECS는 이러한 순간적인 부하도 쉽게 대응 가능</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZCQcmrAomyBf0CP4" /><figcaption>Jenkins가 정상적으로 구축된 모습 (분노가 느껴지는 Jenkins 할아버지로 Theme를 변경)</figcaption></figure><h4>Jenkins Mac mini Agent 연결</h4><p>앞서 말했듯이 AWS EC2 Mac 인스턴스의 높은 비용 문제로 <strong>Mac mini 물리 서버</strong>를 Jenkins Agent로 연결하여 iOS 빌드 환경을 구축했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1XKsJtodt8j8c2uP" /></figure><ul><li>ECS의 Jenkins와 Mac mini를 연결하기 위해 <strong>Jenkins의 Node 기능</strong>을 활용했습니다. ECS의 Jenkins가 Master 역할을 하여 작업을 관리하고 스케줄링하며, Mac mini는 Agent로 연결되어 실제 빌드를 실행합니다. (Jenkins Node 설정 방법: <a href="https://www.jenkins.io/doc/book/managing/nodes/">https://www.jenkins.io/doc/book/managing/nodes/</a>)</li><li>Lambda에서 이벤트 트리거가 발생하면 Master Jenkins가 해당 Pipeline을 Mac mini Agent에 할당하고, Agent에서 Fastlane을 통해 빌드 → 테스트 → 배포가 진행됩니다.</li></ul><h4>Jenkins Node 구성 시 중요한 요소 공유</h4><p>Node를 직접 연결하면서 구성 시 꼭 필요했던 요소들이 존재했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*x-uVcWcdKSqZ7HTQ" /></figure><ul><li><strong>Number of executors</strong>: executor를 여러개로 늘릴 경우 Pipeline을 병렬적으로 처리가 가능 (<strong>성능상 이점을 가져갈 수 있음)</strong></li><li><strong>Remote root directory:</strong> Mac mini의 작업 디렉토리를 명시적으로 설정</li><li><strong>Labels</strong>: Pipeline에서 Node 지정할 때 사용</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Uo3Ux8MOCDO1vH1L" /></figure><ul><li>Jenkins Agent로 연결된 Mac mini에서 빌드 시 터미널에서 직접 실행할 때는 잘 되던 fastlane, tuist, ruby 같은 명령어들을 찾지 못하는 경우가 존재합니다.</li><li>Jenkins Agent는 <strong>non-interactive shell</strong>로 실행되기 때문에 .zshrc나 .bash_profile에 설정된 PATH가 로드되지 않습니다. 즉, 터미널에서 직접 로그인했을 때와 Jenkins가 SSH로 접속했을 때의 환경이 다릅니다.</li><li>Jenkins Node 설정에서 PATH 환경변수를 직접 지정해주어 설치한 패키지들을 사용할 수 있습니다. (which 명령어를 통해 경로 확인 가능)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5MksVkhwGuioy8mJ" /><figcaption>Jenkins Node가 정상적으로 잘 연결된 모습</figcaption></figure><h3>AWS EventBridge 구성</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/833/0*lJ7vX-dHA9xlQAHr" /></figure><p>Jenkins 서버와 Mac mini Agent가 준비되었으니, 이제 CodeCommit의 이벤트를 감지하도록 해야합니다.</p><p>CodeCommit에서 PR 생성 등의 이벤트가 발생하면 EventBridge가 이를 감지하고, 미리 설정한 규칙에 따라 Lambda 함수를 호출 하도록 할 수 있습니다.</p><h4>EventBridge 이벤트 패턴 작성</h4><p>EventBridge는 JSON 형태로 이벤트 패턴을 작성할 수 있습니다.</p><pre>{<br>  &quot;source&quot;: [&quot;aws.codecommit&quot;],<br>  &quot;detail-type&quot;: [&quot;CodeCommit Pull Request State Change&quot;],<br>  &quot;detail&quot;: {<br>    &quot;event&quot;: [&quot;pullRequestCreated&quot;, &quot;pullRequestSourceBranchUpdated&quot;, &quot;pullRequestMergeStatusUpdated&quot;],<br>    &quot;repositoryNames&quot;: [&quot;iOS_repository_name&quot;, &quot;android_repository_name&quot;]<br>  }<br>}</pre><p>1차적으로 CodeCommit의 PR Create, Push, merge 이벤트가 필요했기에 detail-type에 3개의 이벤트를 설정했습니다.</p><ul><li><strong>pullRequestCreated:</strong> PR Create</li><li><strong>pullRequestSourceBranchUpdated:</strong> PR Branch Update</li><li><strong>pullRequestMergeStatusUpdated:</strong> PR Merge</li></ul><p>또한 repositoryNames를 지정하여 iOS, Android 네이티브 repository에서만 이벤트를 감지하도록 필터링했습니다.</p><h3>AWS Lambda 구성 (Jenkins 트리거)</h3><p>EventBridge가 이벤트를 감지하면 Lambda 함수가 호출됩니다. Lambda에서는 이벤트 정보를 파싱하여 Jenkins에 전달 하도록 했습니다.</p><p>구성한 Lambda의 역할은 다음과 같습니다.</p><ol><li>CodeCommit 이벤트에서 필요한 정보(브랜치명, PR ID, 이벤트 타입 등)를 추출합니다.</li><li>추출된 이벤트 타입과 타겟 브랜치에 따라 적절한 <strong>Jenkins Pipeline Token</strong> 선택됩니다.</li><li>선택된 토큰과 빌드 정보를 Jenkins Generic Webhook Trigger로 전달합니다.</li></ol><p><strong><em>Pipeline Token이란?</em></strong></p><ul><li>Jenkins의 <strong>Generic Webhook Trigger</strong> 플러그인을 사용하면 외부에서 HTTP 요청으로 빌드를 트리거할 수 있습니다.</li><li>이때 토큰(token)은 어떤 Pipeline을 실행할지 식별하는 키 역할을 합니다. (<a href="https://plugins.jenkins.io/generic-webhook-trigger/">https://plugins.jenkins.io/generic-webhook-trigger/</a>)</li></ul><pre>&lt;https://jenkins-url/generic-webhook-trigger/invoke?token=token&gt;</pre><h4>Lambda와 EventBridge 연결</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xjejhWQ-prtzFeE1" /></figure><ul><li>생성한 Lambda 함수의 <strong>구성 &gt; 트리거 추가</strong>에서 앞서 생성한 EventBridge 규칙을 추가합니다.</li><li>연결이 완료되면 함수 개요에서 EventBridge가 트리거로 연결된 것을 확인할 수 있습니다.</li></ul><h3>Jenkins Pipeline 구성</h3><p>Lambda에서 트리거 토큰과 빌드 정보를 전달받으면 Jenkins에서 해당 Pipeline이 실행됩니다. (트리거 토큰 1개가 Jenkins Pipeline 1개와 매핑되는 구조입니다.)</p><p>아래는 develop 브랜치로 향하는 Feature PR이 생성 되었을 때 트리거되는 Pipeline 예시 입니다.</p><pre>pipeline {<br>    agent { label &#39;ios-cicd-macmini&#39; } # pipeline 실행할 Agent Node 설정<br><br>    // ========== Webhook Trigger ==========<br>    triggers {<br>        GenericTrigger(<br>            genericVariables: [<br>                [key: &#39;PR_ID&#39;, value: &#39;$.pr_id&#39;]<br>                // SOURCE_BRANCH, TARGET_BRANCH, AUTHOR, SOURCE_COMMIT 등...<br>            ],<br>            token: &#39;**pr-create-develop**&#39;  // Lambda에서 전달하는 Trigger 토큰<br>        )<br>    }<br><br>    // ========== Environment Variables ==========<br>    environment {<br>        // Git, App Store Connect, Match, Jira, Slack 등 필요한 credentials 설정<br>    }<br><br>    // ========== Stages ==========<br>    stages {<br>        stage(&#39;Checkout&#39;) {<br>            steps {<br>                git branch: &quot;${SOURCE_BRANCH}&quot;,<br>                    url: &quot;${env.REPO_URL}&quot;,<br>                    credentialsId: &quot;${env.CREDENTIALS_ID}&quot;<br>            }<br>        }<br><br>        stage(&#39;빌드 시작 ...&#39;) {<br>            steps {<br>                sh &#39;fastlane build&#39;<br>            }<br>        }<br><br>        ...<br>        ...<br>        ...<br>    }<br><br>    // ========== Post Actions ==========<br>    post {<br>        success { echo &#39;✅ Build &amp; Deploy Success&#39; }<br>        failure { echo &#39;❌ Build or Deploy Failed&#39; }<br>    }<br>}</pre><ul><li><strong>agent</strong>: 앞서 설정한 Mac mini Node에서 Pipeline이 실행되도록 라벨을 지정</li><li><strong>triggers</strong>: Generic Webhook Trigger 플러그인을 통해 토큰을 설정. Lambda에서 해당 토큰으로 요청이 오면 이 Pipeline이 실행</li><li><strong>environment</strong>: CI 환경이나 Mac mini 빌드 에이전트에서 사용되는 환경변수를 설정. <a href="https://www.jenkins.io/doc/book/using/using-credentials/">Jenkins의 Credentials</a>를 통해 관리하며, 추후 AWS Secrets Manager로 이관 예정</li><li><strong>stages</strong>: 소스 체크아웃 후 Fastlane을 통해 빌드, 테스트, 배포 등의 lane을 Pipeline 플로우에 맞춰 실행</li></ul><h4>목적 별 다양한 Pipeline 운영</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kwnXS71ZQNL012SF.png" /></figure><p>Jenkins를 통해 목적별로 다양한 Pipeline을 운영할 수 있었습니다.</p><ol><li>예를 들어 PR이 생성될 때는 빌드 + 테스트 + Lint + AI 코드 리뷰 등을 실행하고,</li><li>develop으로 머지될 때는 빌드 + 테스트 후 QA용 TestFlight 업로드 및 Slack 알림까지 전송합니다.</li></ol><p>이처럼 상황과 목적에 따라 서로 다른 Pipeline 구조를 확립하고 운영할 수 있었으며, 현재도 다양한 플로우와 요구사항에 맞춰 새로운 Pipeline을 추가해 나가고 있습니다.</p><h3>Fastlane 구성</h3><h4>lane 구성</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*g0FEku173aFHipFp.png" /></figure><ul><li>Jenkins Pipeline에서 실행되는 <strong>각 Stage는 Fastlane의 lane과 매핑</strong> 되도록 했습니다. 하나의 Pipeline Stage가 하나의 Fastlane lane을 호출하는 구조입니다.</li><li>위 예시는 Pipeline의 qa_deploy Stage가 실행될 때 호출되는 lane입니다. lane 내부에서 빌드, 테스트, 코드 서명, TestFlight 업로드, Slack 알림까지 일련의 작업이 순차적으로 진행됩니다.</li></ul><h4>AWS S3 + Match 구성</h4><pre># S3 기반 Matchfile<br>storage_mode(&quot;s3&quot;)<br>   s3_bucket(&quot;your-s3-bucket-name&quot;)<br>   s3_region(&quot;your-aws-region&quot;)<br>   type(&quot;appstore&quot;) # The default type, can be: appstore, adhoc, enterprise or development</pre><ul><li>Fastlane Match를 도입해서 로컬 개발 환경과 Mac mini CI 환경 모두에서 코드 서명을 위한 구성을 구축했습니다.</li><li>Match를 통해 모든 코드 서명 인증서와 프로비저닝 프로필을 AWS S3 버킷 클라우드 스토리지에 저장하고, 필요한 경우 필요한 인증서와 프로필을 다운로드하여 설치하도록 구성했습니다. (<a href="https://docs.aws.amazon.com/ko_kr/codebuild/latest/userguide/sample-fastlane.html">https://docs.aws.amazon.com/ko_kr/codebuild/latest/userguide/sample-fastlane.html</a>)</li></ul><h4>Fastlane CI 환경 이슈</h4><p>CI 환경에 Fastlane을 통해 iOS 빌드 &amp; 테스트를 진행하며 발견했던 이슈들을 공유하고자 합니다.</p><p><strong>Build Tool Plugin 이슈</strong></p><ul><li>xcodebuild 시 Xcode 14+부터 Swift Package에 <strong>Build</strong> <strong>Plugin</strong>(ex: SwiftLint)이 포함되어 있으면 빌드 시 종속성, 정상 설치 등을 체크하는데 CI 환경에서 <strong>Plugin</strong> 체크가 통과 되지 않는 이슈</li></ul><pre>build_app(<br>      ...<br>      ...<br>      ...<br>      xcargs: &quot;-skipPackagePluginValidation&quot;<br>    )</pre><ul><li><strong>xcargs에 “skipPackagePluginValidation” 옵션 추가</strong></li></ul><p><strong>Swift Macro 패키지 이슈</strong></p><ul><li>xcodebuild 시 Xcode 15+에서 <strong>Swift Macro</strong>를 사용하는 패키지가 있을 때, <strong>Macro 패키지가 활성화 되지 않는 이슈 </strong>(Target ‘ComposableArchitectureMacros’ must be enabled before it can be used.)</li><li>부분적으로 TCA를 사용하는 화면이 존재해서 TCA 관련 Macro 패키지에서 이슈가 발생</li></ul><pre>build_app(<br>      ...<br>      ...<br>      ...<br>      xcargs: &quot;-skipMacroValidation&quot;<br>    )</pre><ul><li><strong>xcargs에 “skipMacroValidation” 옵션 추가</strong></li></ul><p><strong>CI 환경 Rosetta 시뮬레이터 이슈</strong></p><ul><li>프로젝트에 <strong>x86_64 전용 외부 라이브러리</strong>가 포함되어 있어 Rosetta 시뮬레이터에서 빌드/테스트가 필요함. 하지만 CI 환경(Mac mini)에서 Fastlane 실행 시 Rosetta 시뮬레이터를 찾지 못하는 에러가 발생</li></ul><pre>xcodebuild: error: Failed to build workspace Test with scheme Test.:<br>Cannot test target &quot;Test&quot; on &quot;iPhone 16 Pro&quot;:<br>Test does not support any of iPhone 16 Pro&#39;s architectures: arm64원인</pre><ul><li>Xcode26 기본 설치 시 <strong>arm64 시뮬레이터만</strong> 설치됨</li><li>x86_64 라이브러리는 Rosetta 시뮬레이터에서만 동작</li><li>CI 환경에 Rosetta 시뮬레이터가 없어서 테스트 타겟 실행 불가</li></ul><pre># 또는 특정 런타임만 제거<br>xcrun simctl runtime delete all<br><br># Universal (Rosetta 포함) 시뮬레이터 설치<br>xcodebuild -downloadPlatform iOS -architectureVariant universal<br><br># Rosetta 시뮬레이터 목록 확인<br>xcrun simctl list devices | grep -i rosetta<br><br># 시뮬레이터 부팅<br>xcrun simctl boot &quot;iPhone 16 Pro (Rosetta)&quot;</pre><ul><li>Universal (Rosetta 포함) 시뮬레이터 설치 후 빌드 하여 &quot;Booted&quot; 상태로 전환 (<a href="https://stackoverflow.com/questions/79773248/rosetta-simulator-run-destination-not-showing-in-xcode-26">https://stackoverflow.com/questions/79773248/rosetta-simulator-run-destination-not-showing-in-xcode-26</a>)</li></ul><pre>scan(<br>      ...<br>      device: &quot;iPhone 16 Pro&quot;<br>      ...<br>      xcargs: &quot;ARCHS=x86_64&quot;<br>    )</pre><ul><li>Fastlane scan 명령어에선 빌드 기기를 x86으로 강제하고, 빌드 해둔 시뮬레이터 디바이스를 명시적으로 설정하여 x86 시뮬레이터 기기에서만 빌드 및 테스트가 진행되도록 설정</li></ul><h3>CI 파이프라인 완료 후 fastlane 통해 슬랙 메시지 전달</h3><p>Jenkins Pipeline을 통해 fastlane에 구성된 lane을 실행하고, lane에 구성된 flow에 따라 빌드 및 배포가 완료되면 슬랙으로 메시지가 전달되도록 구성했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/874/0*ePXItE91AlBoaCpl" /><figcaption>팀쿡 CEO 알림 봇</figcaption></figure><ul><li><strong>빌드 + 테스트 혹은 CI/CD 관련 에러 슬랙</strong>은 개발자 채널로 필터링했습니다.</li><li>개발자가 빠르게 원인을 파악할 수 있도록 스킴, 타겟 정보, 에러 로그, 테스트 리포트 등을 포함하여 메시지 형식을 구현 했습니다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/642/0*MmBAzyIP-6gicPpG" /><figcaption>팀쿡 CEO 알림 봇 2</figcaption></figure><ul><li>배포 완료 알림은 QA 채널로 전송하여 즉시 테스트 프로세스를 시작할 수 있도록 했습니다.</li><li>QA 알림의 빌드 버전은 Fastlane의 <a href="https://github.com/fastlane/fastlane/tree/master/spaceship">Spaceship ConnectAPI</a>를 통해 App Store Connect에서 최신 마케팅 버전을 조회하여 자동 설정했습니다</li><li>Fastlane에 Jira API를 연동하여 해당 <strong>브랜치/버전에 매칭되는 Jira 티켓 정보를 슬랙 메시지에 포함</strong>했습니다. 이를 통해 QA팀이 어떤 피처/버그 이슈에 대한 배포인지 Jira 티켓 링크를 통해 명확히 파악할 수 있도록 구성했습니다.</li></ul><h3><strong>마치며</strong></h3><p>기존에 익숙했던 GitHub Actions, GitLab CI 환경에서 벗어나 AWS 서비스들을 직접 조합하여 CI/CD 파이프라인을 설계하는 경험이었습니다. 이를 통해 ECS, EventBridge, Lambda 등 다양한 AWS 서비스의 역할과 연결 방식을 깊이 이해할 수 있었습니다.</p><p>또한 평소 접점이 없던 인프라팀과 협업하며 보안 권한 프로세스, AWS 네트워크 구조 등 iOS 개발 외의 영역도 경험할 수 있었습니다.</p><p>이에 끝나지않고 앞으로 빌드 캐싱, 병렬 테스트 등 고도화할 수 있는 부분들도 점진적으로 개선해 나갈 예정입니다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=648dae605c8d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[iOS] TaskLocal (feat: TCA Dependencies)]]></title>
            <link>https://medium.com/@kyuchul2/ios-tasklocal-feat-tca-dependencies-039cf871153a?source=rss-46a4ba84478------2</link>
            <guid isPermaLink="false">https://medium.com/p/039cf871153a</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[swift-programming]]></category>
            <category><![CDATA[swift-concurrency]]></category>
            <category><![CDATA[concurrency]]></category>
            <dc:creator><![CDATA[kyuchulkim]]></dc:creator>
            <pubDate>Thu, 16 Oct 2025 04:10:21 GMT</pubDate>
            <atom:updated>2025-10-16T04:17:07.229Z</atom:updated>
            <content:encoded><![CDATA[<h4>Dependencies에서 TaskLocal를 어떻게 사용 중일까</h4><h3>TaskLocal이란?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cyw2FeKVS77-SH_9qbmyJA.png" /></figure><p>@TaskLocal은 Task의 컨텍스트 내에서 값을 바인딩하고 읽을 수 있도록 해주는 wrapper 타입입니다.</p><p>Task-local 값은 Task와 함께 암묵적으로 전달되며, TaskGroup이나 async let으로 생성된 자식 Task에서도 접근할 수 있습니다. (Sendable 준수 필수)</p><h3>TaskLocal 선언하기</h3><pre> enum Example {<br>      @TaskLocal<br>      static var traceID: TraceID?  // 기본값: nil<br>  }<br><br>  // Swift 6.0부터는 전역 task-local Global 프로퍼티를 지원<br>  @TaskLocal<br>  var contextualNumber: Int = 12<br><br><br>  // Optional이 아닌 경우 명시적으로 기본값을 지정<br>  enum Example {<br>      @TaskLocal<br>      static var traceID: TraceID = TraceID.default<br>  }</pre><ul><li>Task-local 값은 static 프로퍼티 또는 전역 프로퍼티로 선언해야 하며, 기본값을 지정할 수 있습니다.</li></ul><h3>TaskLocal 사용하기</h3><pre>  enum Logger {<br>      @TaskLocal<br>      static var requestID: String?<br>  }<br><br>  Logger.$requestID.withValue(&quot;REQ-001&quot;) {<br>      print(Logger.requestID)  // &quot;REQ-001&quot;<br><br>      // 중첩된 스코프에서 값 변경 가능<br>      Logger.$requestID.withValue(&quot;REQ-002&quot;) {<br>          print(Logger.requestID)  // &quot;REQ-002&quot;<br>      }<br><br>      // 중첩 스코프를 벗어나면 원래 값으로 복귀<br>      print(Logger.requestID)  // &quot;REQ-001&quot;<br>  }</pre><ul><li><strong><em>$taskLocal.withValue(_:operation:)</em></strong> 를 사용하여 스코프 내에서만 값을 바인딩합니다.</li><li>값은 해당 스코프와 그 안에서 생성된 자식 Task에서만 접근 가능합니다.</li></ul><h3>TaskLocal 상속 규칙</h3><pre>  enum Logger {<br>      @TaskLocal<br>      static var requestID: String?<br>  }<br><br>  func read() -&gt; String {<br>      Logger.requestID ?? &quot;no value&quot;<br>  }<br><br>  await Logger.$requestID.withValue(&quot;REQ-123&quot;) {<br>      print(Logger.requestID)  // &quot;REQ-123&quot;<br><br>      // async let: 자식 Task가 값을 상속받음<br>      async let result1 = read()<br>      print(await result1)  // &quot;REQ-123&quot;<br><br>      // TaskGroup: 자식 Task가 값을 상속받음<br>      await withTaskGroup(of: String.self) { group in<br>          group.addTask { read() }<br>          print(await group.next()!)  // &quot;REQ-123&quot;<br>      }<br><br>      // Task: 비구조화 Task지만 값을 복사하여 상속받음<br>      Task {<br>          print(read())  // &quot;REQ-123&quot;<br>      }<br><br>      // Task.detached: 값을 상속받지 않음<br>      Task.detached {<br>          print(read())  // &quot;no value&quot;<br>      }<br>  }</pre><ul><li>TaskLocal 값은 withValue 스코프 내에서 생성된 자식 Task들에게 자동으로 전달됩니다.</li><li><strong>async let, TaskGroup, Task { }</strong> -&gt; TaskLocal 값을 상속받음</li><li><strong>Task.detached { } -&gt; </strong>TaskLocal 값을 상속받지 않음 (완전히 독립적인 Task)</li></ul><h3>TCA Dependencies에서 TaskLocal</h3><p>막상 TaskLocal의 개념은 대충 알겠으나, 어디서 어떻게 사용하면 좋을지 감이 잡히지 않았습니다.</p><p>그러다 회사에서 Dependencies DI를 도입하면서 TCA팀이 TaskLocal을 어떻게 활용하는지 알아볼 기회가 생기게 되었습니다.</p><h4>Dependencies?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aBBnqzeoIx1HQgcnPe3gDw.png" /></figure><ul><li><a href="https://www.pointfree.co/">Point-Free팀</a>이 만든 <a href="https://github.com/pointfreeco/swift-dependencies">Dependencies</a>는 SwiftUI의 Environment에서 영감을 받아 만든 DI 라이브러리입니다.</li></ul><pre>  // 1. DependencyKey로 의존성 등록<br>  extension DependencyValues {<br>      var apiClient: APIClient {<br>          get { self[APIClientKey.self] }<br>          set { self[APIClientKey.self] = newValue }<br>      }<br>  }<br><br>  private enum APIClientKey: DependencyKey {<br>      static let liveValue = APIClient.live    // 실제 앱에서 사용<br>      static let testValue = APIClient.test    // 테스트에서 사용<br>  }<br><br>  // 2. @Dependency로 주입<br>  @Observable<br>  final class FeatureViewModel {<br>      @Dependency(\.apiClient) var apiClient<br><br>      func load() async {<br>          let data = try await apiClient.fetch()<br>      }<br>  }<br><br>  // 3. withDependencies로 테스트<br>  @Test<br>  func test() {<br>      let model = withDependencies {<br>          $0.apiClient = .mock<br>      } operation: {<br>          FeatureViewModel()<br>      }<br>  }</pre><ul><li>위에서 말했듯이, Environment과 그 방식이 매우 흡사합니다. DependencyValues는 SwiftUI의 EnvironmentValues와 유사한 키-값 저장소이며, APIClientKey(키)로 APIClient(값)를 식별합니다.</li><li>liveValue, testValue 등으로 환경별로 다른 구현을 제공합니다.</li></ul><h3>DependencyValues</h3><p>DependencyValue는 내부적으로 TaskLocal을 활용하여 의존성을 관리합니다.</p><pre>  public struct DependencyValues: Sendable {<br>      @TaskLocal<br>      public static var _current = Self() // 현재 의존성 컨테이너<br><br>      @TaskLocal<br>      static var currentDependency = CurrentDependency() // 현재 접근 중인 의존성의 정보 추적용 디버깅 TaskLocal 인스턴스<br><br>      private var storage: [ObjectIdentifier: any Sendable] = [:]<br>      private var context: DependencyContext = defaultContext<br><br>      ...<br>      ...<br>      ...<br>  }</pre><ul><li><strong><em>_current</em></strong>는 현재 의존성 컨테이너 입니다. Task별 독립적인 의존성 저장소 입니다.</li><li>withDependencies로 오버라이드할 때 이 값이 변경되며, 모든 @Dependency 프로퍼티 래퍼가 이 값에서 의존성을 가져옵니다.</li></ul><p><strong>@Dependency 사용 시</strong></p><pre>@Observable<br>  final class FeatureViewModel {<br>      @Dependency(\\.apiClient) var apiClient<br>  }</pre><ul><li>내부적으로 DependencyValues._current[APIClientKey.self] 접근</li></ul><p><strong>withDependencies로 _current 오버라이드</strong></p><pre>withDependencies {<br>      $0.apiClient = .mock  // _current의 storage에 mock 저장<br>  } operation: {<br>      let model = FeatureViewModel()<br>  }<br>  <br> // 스코프 벗어남<br> let anotherModel = FeatureViewModel()</pre><ul><li>model.apiClient 접근 시 → _current에서 mock 가져옴</li><li>_current는 TaskLocal 이기에 anotherModel.apiClient 접근 시 → 원래 _current에서 live 가져옴</li></ul><h3>withDependencies의 동작 원리</h3><ul><li>위에서 간단하게 보시다시피 withDependencies는 특정 스코프에서만 의존성을 다른 값으로 교체할 때 사용합니다. ex) 테스트 시 mock 값으로 변경 등</li></ul><pre>public func withDependencies&lt;R&gt;(<br>      _ updateValuesForOperation: (inout DependencyValues) throws -&gt; Void,<br>      operation: () throws -&gt; R<br>  ) rethrows -&gt; R {<br>      var dependencies = DependencyValues._current // 1<br>      try updateValuesForOperation(&amp;dependencies) // 2<br><br>      return try DependencyValues.$_current.withValue(dependencies) { // 3<br>          try operation() // 4<br>          ...<br>          ...<br>          ...<br>      }<br>  }</pre><ul><li>withDependencies는 기존 _current를 복사하므로 다른 의존성은 그대로 유지됩니다.</li><li>$_current.withValue()로 TaskLocal 오버라이드하며, 스코프를 벗어나면 자동으로 원래 _current로 복귀하게됩니다. → <strong>TaskLocal은 변경한 클로저 내부 혹은 자식 작업에게만 영향을 끼침</strong></li><li>withDependencies의 실제 코드 중 핵심이 되는 부분만 가져와서 실제로 어떻게 동작하는지 파악해봤습니다.</li></ul><ol><li><strong>현재 _current 복사</strong><br>- var dependencies = DependencyValues._current<br>- 현재 Task의 _current를 복사 (기존 의존성 유지)</li><li><strong>updateValuesForOperation 클로저로 의존성 수정</strong><br>- try updateValuesForOperation(&amp;dependencies)<br>- ex) // $0.apiClient = .mock이 실행됨<br>- ex) // dependencies.storage[APIClientKey] = .mock</li><li><strong>TaskLocal 값 오버라이드</strong><br>- DependencyValues.$_current.withValue(dependencies) {<br>- TaskLocal의 withValue로 새로운 dependencies를 이 스코프에만 적용<br>- 이 블록 내부의 모든 코드는 수정된 _current 사용</li><li><strong>스코프 내에서만 수정된 의존성 사용</strong><br>- try operation()<br>- ex) FeatureViewModel() 생성 시 @Dependency(\.apiClient)가 수정된 _current에서 .mock 가져옴</li></ol><h3>TaskLocal의 “격리” 효과</h3><pre>@Test<br>  func testLogin() async {<br>      let model = withDependencies {<br>          $0.apiClient = .mock  // 이 테스트만 mock 사용<br>      } operation: {<br>          LoginViewModel()<br>      }<br><br>      await model.login()<br>      #expect(model.isLoggedIn == true)<br>  }<br><br>  @Test<br>  func testLogout() async {<br>      let model = withDependencies {<br>          $0.apiClient = .failing  // 이 테스트는 failing 사용<br>      } operation: {<br>          LoginViewModel()<br>      }<br><br>      await model.logout()<br>      #expect(model.errorMessage != nil)<br>  }<br>  <br>  // Singleton 방식의 문제<br>  @Test<br>  func testA() async {<br>      DependencyContainer.shared.apiClient = .mock<br>      // testA 로직...<br>  }<br><br>  @Test<br>  func testB() async {<br>      // testB는 .live를 기대했지만 .mock이 되어있음<br>      let model = FeatureViewModel()<br>  }</pre><ul><li>TaskLocal의 &quot;격리&quot; 효과를 명확히 알 수 있었던건 테스트 코드를 작성할 때 였습니다. withDependencies를 통해 각 테스트가 독립적인 의존성 컨텍스트를 가지도록 구성할 수 있습니다.</li><li>만약 TaskLocal이 아닌 Singleton 방식이였다면 테스트 간 &quot;전염성&quot; 문제로 테스트 실행 순서에 따라 결과가 달라지는 불안정한 테스트 환경이 구축될 수 있었습니다.</li></ul><h3>마치며</h3><p>Dependencies 라이브러리를 뜯어보고 사용하면서 TaskLocal을 어떻게 활용할 수 있는지 이해할 수 있었습니다. 단순히 “Task마다 값을 저장할 수 있다”는 개념을 넘어, 의존성 격리라는 실질적인 문제를 해결하는 모습을 보며 좋은 충격을 받았습니다.</p><p>TCA 팀의 여러 코드를 보며 TaskLocal뿐만 아니라 Sendable, Actor 등 Swift Concurrency의 요소를 정말 깊이 이해하고 활용한다는 느낌을 받았습니다.</p><p>좋은 라이브러리는 단순히 문제를 해결하는 것을 넘어, 언어의 기능을 어떻게 활용해야 하는지 가르쳐주는 것 같습니다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=039cf871153a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[iOS 화면전환 리팩토링 기록 (1) — Navigation, DI 구조 선택 과정]]></title>
            <link>https://medium.com/@kyuchul2/ios-%ED%99%94%EB%A9%B4%EC%A0%84%ED%99%98-%EB%A6%AC%ED%8C%A9%ED%86%A0%EB%A7%81-%EA%B8%B0%EB%A1%9D-1-navigation-di-%EA%B5%AC%EC%A1%B0-%EC%84%A0%ED%83%9D-%EA%B3%BC%EC%A0%95-6f1de9b6b9ba?source=rss-46a4ba84478------2</link>
            <guid isPermaLink="false">https://medium.com/p/6f1de9b6b9ba</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[navigation]]></category>
            <category><![CDATA[dependency-injection]]></category>
            <category><![CDATA[swiftui]]></category>
            <category><![CDATA[coordinator]]></category>
            <dc:creator><![CDATA[kyuchulkim]]></dc:creator>
            <pubDate>Tue, 30 Sep 2025 06:24:13 GMT</pubDate>
            <atom:updated>2026-04-11T16:48:20.049Z</atom:updated>
            <content:encoded><![CDATA[<h3>SwiftUI 프로젝트 화면전환 리팩토링 기록</h3><h4>Navigation, DI 구조 선택 과정</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iBwt0kpy-RWldspx-W7iOg.png" /></figure><h3>들어가며</h3><p>재직 중인 회사의 iOS는 첫 출시부터 SwiftUI가 전면 도입되어 있었습니다. 하지만 당시 SwiftUI는 아직 초기 단계였고, 안정성과 기능 면에서 많은 제약이 있었습니다.</p><p>또한 빠른 출시 일정이 요구되면서, 아키텍처의 완성도보다는 일정 준수가 더 중요한 목표가 되었던 걸로 판단됩니다. 이에 따라 현재 코드 구조에는 아쉬움이 남아 있었습니다.</p><p>특히 사용자 경험에 직접적인 영향을 미치는 화면 전환 구조는 더 이상 미룰 수 없는 리팩토링 대상이었습니다.</p><h3>기존 화면 전환의 문제점</h3><pre>struct TestView: View {<br>    @State private var showDetailView: Bool = false<br><br>    var body: some View {<br>        ZStack {<br>            // 메인 화면<br>            Button(&quot;상세 화면 열기&quot;) {<br>                showDetailView = true<br>            }<br><br>            if showDetailView {<br>                DetailView(isPresented: $showDetailView)<br>                    .transition(AnyTransition.asymmetric(<br>                        insertion: .move(edge: .trailing),<br>                        removal: .move(edge: .leading))<br>                    )<br>            }<br>        }<br>    }<br>}</pre><ul><li>대부분의 화면 전환이 SwiftUI의 네비게이션 시스템을 우회하는 방식으로 구현되어 있었습니다</li><li>ZStack으로 화면을 겹쳐 놓고, @State 변수로 표시 여부를 제어하며, transition 모디파이어로 화면 전환 효과가 발생한 것 처럼 보이게 하는 방식이었습니다.</li><li>겉보기엔 화면 전환 처럼 보이지만 실제로는 모든 View가 View Hierarchy에 남아있는 show/hide 방식이라고 볼 수 있습니다.</li></ul><p><strong><em>이러한 방식의 문제점은 다음과 같습니다.</em></strong></p><p><strong>1. 스와이프 백 제스처 불가능</strong></p><ul><li>네비게이션을 사용하지 않았기 때문에 시스템이 제공하는 네이티브 제스처를 사용할 수 없습니다.</li></ul><p><strong>2. 불필요한 View 렌더링 비용</strong></p><pre>ZStack {<br>    MainView()      // 항상 메모리에 존재<br>    if showDetail {<br>        DetailView() // MainView 위에 단순히 덮어씌움<br>    }<br>}</pre><ul><li>DetailView가 표시되어도 MainView는 여전히 뒤에서 렌더링되고 있습니다.</li><li>화면이 깊어질수록 (A → B → C → D) 모든 이전 화면들이 View Hierarchy에 남아있습니다.</li></ul><p><strong>3. 상태 관리의 복잡성</strong></p><pre>struct MainView: View {<br>    @State private var showA = false<br>    @State private var showB = false<br>    // ... showC, showD, showE<br><br>    var body: some View {<br>        ZStack {<br>            if showA { ViewA() }<br>            if showB { ViewB() }<br>            // ... ViewC, ViewD, ViewE<br>        }<br>    }<br>}<br><br>// E → A 가려면?<br>func goToAFromE() {<br>    showB = false<br>    showC = false<br>    showD = false<br>    showE = false<br>    showA = true<br>}</pre><ul><li>E에서 A로 가려면 모든 중간 화면의 상태를 알고 제어해야 합니다.</li><li>새로운 화면 F를 추가하려면? 모든 기존 화면에서 showF 처리를 추가해야 합니다.</li></ul><p><strong>4. 네비게이션 히스토리 추적 불가능</strong></p><ul><li>현재 경로 파악 불가: 사용자가 Main → A → B → C로 왔는지, Main → B → C로 왔는지 알 수 없습니다.</li><li>디버깅 지옥: 화면 전환 버그 발생 시 어떤 Bool 변수가 문제인지 추적이 어렵습니다.</li></ul><h3>네비게이션 관리 방식 선택하기</h3><p>리팩토링의 첫 과제는 네비게이션 구조 선택이었습니다. 네비게이션 관리 방식 결정에 있어 두 가지 기준을 설정했습니다.</p><ul><li><strong>사용 중인 UI 프레임워크</strong></li><li><strong>최소 지원 버전</strong></li></ul><p>현재 iOS 서비스는:</p><ul><li><strong>SwiftUI 전면 사용 중</strong></li><li><strong>iOS15 최소 지원</strong></li></ul><p>SwiftUI의 네비게이션 시스템은 최소 지원 버전 iOS16을 기준으로 완전히 달라집니다. iOS16 미만에서는 NavigationView(Deprecated)만 사용 가능하지만, iOS16부터는 NavigationStack을 지원합니다. 그러나 재직중인 회사 iOS 서비스는 최소 지원 버전이 iOS15였기에 두 가지 방안을 검토했습니다.</p><h4>1. SwiftUI + UINavigationController</h4><ul><li>UIHostingController로 SwiftUI View를 래핑</li><li>UINavigationController로 화면 전환 관리</li><li>UIKit Coordinator 패턴 활용</li></ul><h4>2. NavigationStack 도입</h4><ul><li>최소 버전을 iOS16으로 상향</li><li>SwiftUI 네이티브 솔루션 활용</li></ul><h3>SwiftUI + UINavigationController</h3><p>재직중인 회사의 iOS 최소 버전을 iOS15로 유지 한다는 가정하에, deprecated된 NavigationView를 사용하기에는 고질적인 문제가 많았습니다.</p><p>결국 UIKit의 검증된 <strong>UINavigationController를 SwiftUI와 결합</strong>하는 것이 가장 현실적인 해결책이라 판단했습니다.</p><pre>// Coordinator<br>class AppCoordinator {<br>    let nav: UINavigationController<br><br>    func pushDetail() {<br>        nav.push(UIHostingController(rootView: DetailView(coordinator: self)))<br>    }<br>}<br><br>// SceneDelegate<br>class SceneDelegate: UIResponder, UIWindowSceneDelegate {<br>    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options: UIConnectionOptions) {<br>        let coordinator = AppCoordinator(nav: UINavigationController())<br>        coordinator.start()<br>        // ...<br>    }<br>}<br><br>// SwiftUI<br>struct ContentView: View {<br>    let coordinator: AppCoordinator<br><br>    var body: some View {<br>        Button(&quot;Push&quot;) {<br>            coordinator.pushDetail()<br>        }<br>    }<br>}</pre><ul><li>SceneDelegate를 앱의 시작점으로 변경하고, 모든 SwiftUI 뷰를 UIHostingController로 감싸서 UINavigationController를 사용할 수 있도록 구성했습니다.</li><li>여기에 <a href="https://khanlou.com/2015/01/the-coordinator/">Coordinator 패턴</a>을 도입하여 네비게이션 로직을 View에서 완전히 분리했습니다.</li></ul><p>이 방식의 큰 장점은 <strong>안정성</strong>입니다. UIKit의 10년 이상 검증된 네비게이션 시스템을 그대로 활용할 수 있다는 점입니다.</p><p>아키텍처 측면에서도 이점이 많았습니다</p><ul><li><strong>SRP(단일 책임 원칙) 준수</strong>: Coordinator가 모든 네비게이션을 전담</li><li><strong>낮은 결합도</strong>: View는 다른 View의 존재를 몰라도 됨</li><li><strong>추상화 의존</strong>: View는 구체적인 네비게이션 구현이 아닌 Coordinator 프로토콜에만 의존</li></ul><h3>SwiftUI에서 UIKit Coordinator를 고민하며 다시 본 DI 구조</h3><p>화면 전환의 본질은 단순한 View 이동이 아닙니다. 다음 화면의 인스턴스를 생성하고, 필요한 의존성을 주입하며, 생명주기를 관리하는 책임의 영역입니다.</p><p>UIKit 기반 Coordinator 도입을 고민하면서, 이러한 책임 분리와 DI(Dependency Injection) 구조 전반에 대해서도 다시 생각하게 되었습니다.</p><h4>UIKit Coordinator와 명시적 주입</h4><pre>  // HomeCoordinator<br>  class HomeCoordinator {<br>    private let nav: UINavigationController<br>    private let dependencies: AppDependencies<br><br>    init(nav: UINavigationController, dependencies: AppDependencies) {<br>      self.nav = nav<br>      self.dependencies = dependencies<br>    }<br><br>    func showHome() {<br>      // 프로토콜 타입으로 주입<br>      let viewModel = HomeViewModel(userUseCase: dependencies.userUseCase)<br>      let view = HomeView(viewModel: viewModel)<br>      nav.pushViewController(UIHostingController(rootView: view), animated: false)<br>    }<br>  }<br><br>  // HomeViewModel - 프로토콜 타입 받기<br>  class HomeViewModel {<br>    private let userUseCase: UserUseCase  // 프로토콜 타입<br><br>    init(userUseCase: UserUseCase) {  // 외부에서 생성한 인스턴스를 이니셜라이저로 주입<br>      self.userUseCase = userUseCase<br>    }<br>  }</pre><ul><li><strong>Coordinator는 ViewController 생성 시점에 필요한 의존성을 직접 주입</strong>합니다. 따라서 <strong>화면 생성 책임과 DI 책임이 Coordinator에 함께 모이게 됩니다.</strong></li><li>명령형 방식의 UIKit 기반 Coordinator 패턴에는 <strong>명시적(Explicit) 주입</strong> 방식이 자연스럽게 어울렸습니다.</li><li>명시적 주입은 주로 생성자(Constructor)나 setter를 통해 주입하는데, Coordinator 패턴에서는 ViewController를 생성할 때 필요한 모든 것을 명시적으로 전달하기 때문입니다.</li></ul><h4>명시적 주입의 장점</h4><p><strong>잘 드러나는 의존성</strong></p><pre>// 암시적 주입 - 의존성이 숨겨짐<br>struct DetailView: View {<br>    @EnvironmentObject var cartManager: CartManager<br>    @EnvironmentObject var userSession: UserSession<br>    // 더 추가해도 티가 안남...<br>}<br><br>// 명시적 주입 - 의존성이 명확히 드러남<br>struct DetailView: View {<br>    init(cartManager: CartManager,<br>         userSession: UserSession,<br>         analytics: Analytics,<br>         cacheManager: CacheManager) { // 이니셜라이저가 비대해짐<br>        // &quot;이 View가 너무 많은 책임을 갖고 있구나&quot; 바로 파악 가능<br>    }<br>}</pre><ul><li>&quot;이 View가 뭘 필요로 하는가&quot;가 이니셜라이저 시그니처에 명확히 드러남</li><li>이니셜라이저가 비대해지면 &quot;이 객체가 SRP를 위반하고 있다&quot;는 코드 스멜이 명확히 드러납니다.</li></ul><p><strong>테스트 용이성</strong></p><pre>// 명시적 주입 - 테스트에 필요한 의존성이 바로 보임<br>class DetailViewTests: XCTestCase {<br>    func testAddToCart() {<br>        // 이니셜라이저를 보면 뭘 준비해야 하는지 명확<br>        let view = DetailView(<br>            cartManager: MockCartManager(),  // 필수<br>            analytics: MockAnalytics()       // 필수<br>        )<br>        // 컴파일러가 빠진 의존성을 알려줌<br>    }<br>}</pre><ul><li>필요한 의존성이 명확함(테스트 시 필요한 의존성만 정확히 제공)</li><li>Mock 객체 주입이 간단명료</li></ul><h4>SwiftUI의 암묵적 주입 방식</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1013/0*LFk7BZrnjqKFDl_v.png" /></figure><ul><li>SwiftUI는 선언적 UI 방식과 값 타입 View의 특성상 <strong>암묵적(Implicit) 주입 방식이 적합 할 수 있습니다.</strong></li><li><strong>선언적 UI와 조화:</strong> SwiftUI는 View를 상태의 함수로 정의하며, “무엇”을 선언하고 “어떻게”는 프레임워크가 처리합니다. Environment, EnvironmentObject는 의존성을 View 계층에 자동 전파하여 간결한 View 정의를 유지합니다. (View가 의존성을 선언적으로 조회)</li><li><strong>값 타입 뷰의 특성</strong>: SwiftUI 뷰는 구조체로, 가볍게 재생성됩니다. 명시적 이니셜라이저 주입은 prop-drilling을 유발하고 코드 복잡도를 높이지만, 암묵적 주입은 의존성을 환경값 컨테이너로 관리해 이를 방지합니다.</li></ul><p><strong>Environment와 EnvironmentObject</strong></p><pre>struct MyCustomKey: EnvironmentKey {<br>    static let defaultValue: String = &quot;Default&quot;<br>}<br><br>extension EnvironmentValues {<br>    var myCustomValue: String {<br>        get { self[MyCustomKey.self] }<br>        set { self[MyCustomKey.self] = newValue }<br>    }<br>}<br><br>struct MySwiftUIView: View {<br>    @Environment(\\.myCustomValue) var customValue // 환경에서 값 조회<br><br>    var body: some View {<br>        Text(customValue)<br>    }<br>}<br><br>// @Entry<br>extension EnvironmentValues {<br>    @Entry var myCustomValue: String = &quot;Default&quot;<br>}</pre><ul><li><strong>Environment</strong>: EnvironmentValues 환경 값 스레드 로컬 컨텍스트를 통해 의존성을 저장하고 @Environment로 조회하는 방식</li><li>WWDC2024에서 발표한 <strong>Entry macro를 사용하면 더 간결하게 사용도 가능</strong></li></ul><pre>struct MySwiftUIView: View {<br>    @EnvironmentObject var viewModel: MyViewModelable<br><br>    var body: some View {<br>        Text(viewModel.message)<br>        Button(&quot;Update&quot;) { viewModel.message = &quot;Updated!&quot; }<br>    }<br>}</pre><ul><li><strong>EnvironmentObject</strong>: 부모 뷰에서 주입된 ObservableObject를 자식 뷰에서 자동으로 사용.</li><li>의존성을 뷰 계층에 공유하여 prop-drilling 없이 데이터 접근.</li></ul><p><strong><em>Environment와 EnvironmentObject는 DI인가? (사견)</em></strong></p><ul><li>Environment와 EnvironmentObject는 SwiftUI의 뷰 계층에 암묵적으로 의존성을 주입하는 메커니즘입니다.</li><li>DI의 본질은 인터페이스(프로토콜) 기반으로 구현체 의존성을 줄이는 것인데, SwiftUI의 Environment는 구체 타입에 의존하는 제약이 있습니다.</li><li>인터페이스 추상화는 제한적이지만, 뷰 계층에 암묵적으로 주입하는 역할을 한다는 점에서 필자는 DI의 한 형태라고 소개해봤습니다.</li></ul><h4>기존 DI 구조와의 불협화음</h4><blockquote><strong>UIHostingController의 EnvironmentObject 전파 단절</strong></blockquote><pre>@main<br>struct TeslaApp: App {<br>    // 출금 플로우 상태 관리<br>    @StateObject var withdrawalFlowObject = WithdrawalFlowObject()<br><br>    // 홈 화면 플로우 관리<br>    @StateObject var homeFlowObject = HomeFlowObject()<br><br>    // 사용자 인증 상태<br>    @StateObject var authManager = AuthManager()<br><br>    // ... 더 많은 StateObject들<br><br>    var body: some Scene {<br>        WindowGroup {<br>            ContentView()<br>                .environmentObject(withdrawalFlowObject)<br>                .environmentObject(homeFlowObject)<br>                .environmentObject(authManager)<br>                // ... 모든 StateObject 주입<br>        }<br>    }<br>}<br><br>// 각 뷰에서 필요한 EnvironmentObject 사용<br>struct HomeView: View {<br>    @EnvironmentObject var homeFlow: HomeFlowObject<br>}<br><br>struct WithdrawalView: View {<br>    @EnvironmentObject var withdrawalFlow: WithdrawalFlowObject<br>    @EnvironmentObject var auth: AuthManager<br>}</pre><ul><li>현재 재직중인 회사의 iOS 프로젝트는 비즈니스 로직 중 상당 부분이 EnvironmentObject로 주입되고 있는 상황입니다.</li><li>기존 EnvironmentObject는 유지하면서, UIKit Coordinator와 공존하도록 할 때 아래와 같은 이슈가 발생했습니다.</li></ul><pre>// SceneDelegate에서<br>let coordinator = AppCoordinator()<br>let rootView = ContentView(coordinator: coordinator)<br>    .environmentObject(authManager)  // ⚠️ 여기서 주입<br><br>// 하지만 Coordinator에서 새 화면을 push할 때<br>func pushWithdrawal() {<br>    let withdrawalView = WithdrawalView()  // ❌ environmentObject 없음!<br>    nav.push(UIHostingController(rootView: withdrawalView))<br>}<br><br>// WithdrawalView에서<br>struct WithdrawalView: View {<br>    @EnvironmentObject var authManager: AuthManager  // 💥 크래시!<br>}</pre><ul><li>UIHostingController는 각각 독립된 SwiftUI 환경 컨테이너를 가집니다. 따라서 EnvironmentObject는 호출된 HostingController 내에서만 유효합니다. 즉, 각 View 별로 UIHostingController로 화면을 래핑하여 push하는 패턴에서는 매번 주입하지 않으면 환경이 끊기게 됩니다.</li><li>SwiftUI의 EnvironmentObject는 한 번만 주입하고 하위 뷰들이 자연스럽게 상속받는 구조입니다. 하지만 UIKit에서 화면을 분리하면, SwiftUI View들은 서로 아무 관계가 없는 섬처럼 존재하게 됩니다.</li></ul><p><strong>복잡한 EnvironmentObject 보일러플레이트 코드</strong></p><pre>class AppCoordinator {<br>    // 모든 환경 객체를 Coordinator가 보관<br>    let appState = AppState()<br>    let cartManager = CartManager()<br>    let userSettings = UserSettings()<br><br>    func pushWithdrawal() {<br>        let withdrawalView = WithdrawalView()<br>            .environmentObject(appState)<br>            .environmentObject(cartManager)<br>            .environmentObject(userSettings)<br>            // 매번 모든 것을 수동 주입<br><br>        nav.push(UIHostingController(rootView: withdrawalView))<br>    }<br><br>    // 새로운 환경 객체 추가할 때마다<br>    // 모든 push 메서드 수정 필요<br>}</pre><ul><li>기존에 EnvironmentObject를 사용하는 구조를 UIKit 기반의 Coordinator 패턴으로 마이그레이션하기 위해서는 매번 수동 주입을 해야 하는 복잡한 보일러플레이트 코드가 발생합니다</li><li>매 화면마다 .environmentObject(_:)를 주입해야 하므로 실수나 누락 가능성으로 인해 런타임 크래시 가능성이 존재하고, 앱의 전체적인 구조를 파악하기 어렵습니다.</li><li>최종적으로 UIHostingController를 여러 개 사용하는 방식은 SwiftUI의 <strong>“의존성 자동 전파”</strong> 매커니즘과 충돌한다고 느껴졌습니다.</li></ul><blockquote><strong>프로젝트에선 암묵적(Implicit) 주입 사용 중</strong></blockquote><ul><li>재직중인 회사의 iOS 프로젝트는 RIBs, TCA 같은 프레임워크 없이 순수 Vanila SwiftUI + MVVM 구조로 구성 되어 있습니다. ViewModel에서 비즈니스 로직을 처리하고, 테스트 더블을 쉽게 수행할 수 있도록 설계되었습니다.</li><li>SwiftUI View 계층에서는 @Environment와 @EnvironmentObject를 사용해 의존성을 암묵적으로 주입하지만, 이는 View에 국한됩니다. ViewModel이나 UseCase 같은 비즈니스 로직 객체에서도 Environment와 같은 암묵적 주입 방법이 필요했고, TCA의 Dependencies DI를 사용 중에 있습니다.</li></ul><p><strong>TCA의 Dependencies DI</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/581/0*Z1gViVdRCVxbaMwQ.png" /></figure><ul><li>실제로 TCA의 <a href="https://swiftpackageindex.com/pointfreeco/swift-dependencies/main/documentation/dependencies/whataredependencies">Dependencies</a>는 SwiftUI의 @Environment에서 영감을 받아, 뷰 외부에서도 선언적이고 간결한 DI를 제공합니다.</li></ul><pre>import Dependencies<br><br>// DependencyKey 구현<br>struct AttemptUseCaseKey: DependencyKey {<br>    static let liveValue: AttemptUseCase = RealAttemptUseCase()<br>}<br><br>// DependencyValues에 등록<br>extension DependencyValues {<br>    var attemptUseCase: AttemptUseCase {<br>        get { self[AttemptUseCaseKey.self] }<br>        set { self[AttemptUseCaseKey.self] = newValue }<br>    }<br>}<br><br>class MyViewModel: ObservableObject {<br>    @Dependency(\\\\.attemptUseCase) var useCase // 암묵적 주입<br>    @Published var result = &quot;&quot;<br><br>    func performAction() {<br>        result = useCase.execute()<br>    }<br>}</pre><ul><li>@Environment가 EnvironmentValues를 통해 뷰 계층에 의존성을 전파하듯, DependencyValues를 사용해 뷰 외부의 객체에서도 간결하고 선언적인 의존성 주입을 지원합니다.</li><li>Dependencies DI 도입 관련 내용은 별도 블로그에서 다룰 예정입니다.</li></ul><h3>최종 선택: 최소 버전 상향으로 NavigationStack 도입</h3><p>지금까지 UIKit Coordinator 도입을 검토한 내용을 길게 다뤘는데, 결국 NavigationStack을 선택했다니 의아하실 수 있습니다. 하지만 아래와 같은 이유로 최종적으론 NavigationStack 도입을 결정하게 되었습니다.</p><h4>1. DI 패러다임 선택: 암묵적 주입의 실용성</h4><ul><li>UIKit Coordinator를 도입하면 전통적인 명시적 주입의 장점을 살릴 수 있습니다.</li><li>그러나 현재 프로젝트는 기존 EnvironmentObject와 TCA의 Dependencies를 혼용해 암묵적 의존성 주입을 사용 중이였고, 기존의 주입 방식을 변경할 만큼의 단점을 찾지 못했습니다.</li></ul><p><strong>1. 잘 드러나지 않는 의존성 극복</strong></p><ul><li>명시적 주입(예: 이니셜라이저 주입)은 의존성을 이니셜라이저나 프로퍼티로 명확히 드러내어 단일 책임 원칙(SRP) 위반을 쉽게 감지할 수 있습니다.</li><li>반면, 암묵적 주입(예: SwiftUI의 @Environment, @EnvironmentObject)은 의존성이 코드에 직접 드러나지 않아 가시성이 낮을 수 있다는 단점(Ambient Context Issue)이 있습니다.</li></ul><p>하지만, SwiftUI의 암묵적 주입은 아래 장점들로 이 단점을 상쇄하며, 선언적 UI에 더 적합하다고 생각했습니다.</p><ul><li>계층에 의존성 자동 전파: SwiftUI의 @Environment와 dependencies의 @Dependency는 의존성을 View 계층이나 DependencyValues 컨텍스트에 자동 전파하여 prop-drilling(계층적 전달)을 제거합니다. 이는 명시적 주입의 보일러플레이트 코드를 해결하고, 선언적 UI의 코드 간결성을 유지합니다.</li><li>개발 속도 증가: 명시적 주입은 뷰 계층이 깊어질수록 각 뷰에 이니셜라이저를 정의하고 의존성을 전달해야 합니다. 암묵적 주입은 이를 제거해 개발 속도를 높이고 유지보수성을 향상시킵니다. (property wrapper를 사용해 의존성 주입을 간소화)</li></ul><p><strong>2. 테스트 용이성</strong></p><pre>import Dependencies<br><br>struct MockService: Service {<br>    func fetchData() { print(&quot;Mock fetch&quot;) }<br>}<br>// 테스트 코드<br>withDependencies {<br>    $0[ServiceKey.self] = MockService() // 모의 객체 주입<br>} operation: {<br>    let viewModel = MyViewModel()<br>    viewModel.fetch() // MockService의 fetchData 호출<br>}</pre><ul><li>테스트 용이성은 dependencies 도입을 통해 해결 할 수 있었습니다.</li><li>withDependencies를 사용해 테스트 환경에서 Mock 객체 의존성을 동적으로 변경 가능. 이는 명시적 주입의 테스트 용이성을 대체하며, 설정이 더 간결합니다.</li></ul><h4>2. SwiftUI 선언적 패러다임의 일관성 유지</h4><ul><li>SwiftUI는 <strong>선언형</strong>, UIKit은 <strong>명령형 UI 프레임워크</strong>입니다.</li></ul><p><em>SwiftUI에서는 </em><strong><em>“상태”를 선언</em></strong><em>하면 프레임워크가 화면 전환을 알아서 처리합니다.</em></p><p><em>UIKit에서는 </em><strong><em>뷰 컨트롤러 생성 → 네비게이션 컨트롤러에 push</em></strong><em> 같은 과정을 직접 명령해야 합니다.</em></p><ul><li><strong>선언형 패러다임의 일관성</strong>을 유지하여 코드의 예측 가능성과 유지보수성 향상</li><li>SwiftUI의 지속적인 발전(NavigationStack, Observable 등)에 즉시 대응 가능한 구조 확보</li></ul><h4>3. 기술 스택의 미래 지향성 vs 당장의 안정성</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/0*YmDCb1cKqfKEvNvV.png" /></figure><ul><li>마틴 파울러는 <em>Technical Debt Quadrant에서</em> “기술 부채는 단순히 나쁜 것이 아니라 의도적이고 전략적일 때 의미가 있습니다.” 라고 합니다.</li><li>“SwiftUI로 만든 앱을 다시 UIKit으로 감싸는 것이 맞을까?” 이는 단기적 안정성을 위해 UIKit에 회귀하는 선택일 수 있습니다. 하지만 이는 결국 <strong>기술 부채 위에 더 큰 기술 부채를 쌓는 것</strong>과 같다고 판단했습니다. 부채를 늘리기보다, 오히려 <strong>SwiftUI라는 미래 지향적 선택을 지키는 것</strong>을 택했습니다.</li></ul><h3>마치며</h3><p>이번 글은 원래 실제 화면전환 구현을 소개하려고 시작했습니다.</p><p>하지만 실제 화면전환을 고민하다 보니, 단순히 “화면을 오가게 만드는 기능”이 아니라 기술 스택 선택, 최소 지원 버전 결정, 의존성 주입 구조 설계와도 깊이 연결되어 있다는 점을 다시 확인하게 되었습니다.</p><p>따라서 이번 편은 화면전환 자체를 다루기보다, 그 기반이 되는 고민을 먼저 정리하는 내용으로 마무리하게 되었습니다.</p><p>다음 편에서는 본격적으로 NavigationStack을 활용하여 어떻게 화면전환 구조를 설계했는지, 그리고 그 과정에서 어떤 장단점을 고려했는지를 다루겠습니다.</p><h4>번외) 말단 개발자가 iOS 최소 버전을 올리기 위해 만든 공유 문서</h4><p>네비게이션 기술 스택을 정했지만, 사용을 위해 <strong>iOS16 최소 지원</strong>이 필요했습니다. 하지만 최소 버전 상향은 기존 유저 이탈 리스크가 있고, <strong>기술 개선의 가치는 겉으로 드러나지 않아</strong> 다른 부서에서는 그 가치를 체감하기 어렵습니다.</p><p>따라서 “개발 편의성”이 아닌 <strong>“서비스 경쟁력”</strong> 관점에서 설득 자료를 준비했습니다.</p><p><strong>1. 실제 OS 채택률 데이터</strong></p><ul><li>App Store Connect 분석 기능</li><li>특정 기간, 기기별 OS 버전, 활성 기기 필터 활용</li><li>Firebase/Sentry 데이터로 iOS 15 이하 실사용자 비율 추적 -&gt; 최소 버전 상향이 전체 유저에 미치는 영향이 미미함을 수치로 증명</li></ul><p><strong>2. 애플 공식 통계</strong></p><ul><li><a href="https://developer.apple.com/kr/support/app-store/">애플이 공개한 iOS 버전별 점유율 자료</a> 활용</li></ul><p><strong>3. 연동 서비스 최소 버전 분석</strong></p><ul><li>알림톡, 제휴사 앱 등 <strong>우리 서비스와 연동되는 서비스</strong>들의 최소 버전 조사</li><li>iOS 15 유저는 이미 핵심 서비스 흐름이 끊기는 상황임을 입증</li><li>단순히 많이 사용되는 앱과 비교하기보다는, <strong>우리 서비스와 직접적인 연동 관계가 있는 앱</strong> 지원 버전을 함께 고려</li></ul><p><strong>4. 백엔드팀과 협업: 핵심 지표 분석</strong></p><ul><li>iOS 15 이하 유저의 실제 서비스 활용도가 극히 낮음을 확인</li></ul><p>이런 데이터를 이해하기 쉬운 시각 자료로 만들어 공유했고, 최종적으로 iOS 16 최소 버전 상향을 이끌어낼 수 있었습니다.</p><h3>참고 자료</h3><ul><li><a href="https://swiftpackageindex.com/pointfreeco/swift-dependencies/main/documentation/dependencies/whataredependencies">https://swiftpackageindex.com/pointfreeco/swift-dependencies/main/documentation/dependencies/whataredependencies</a></li><li><a href="https://martinfowler.com/bliki/TechnicalDebtQuadrant.html?utm_source=chatgpt.com">https://martinfowler.com/bliki/TechnicalDebtQuadrant.html</a></li><li><a href="https://soojin.ro/blog/ambient-context-anti-pattern">https://soojin.ro/blog/ambient-context-anti-pattern</a></li><li><a href="https://medium.com/@kyuchul2/wwdc-2020-data-essentials-in-swiftui-f55f1de383af">https://medium.com/@kyuchul2/wwdc-2020-data-essentials-in-swiftui-f55f1de383af</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f1de9b6b9ba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[WWDC 2021] Demystify SwiftUI]]></title>
            <link>https://medium.com/@kyuchul2/wwdc-2021-demystify-swiftui-9842c3d38203?source=rss-46a4ba84478------2</link>
            <guid isPermaLink="false">https://medium.com/p/9842c3d38203</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[swiftui]]></category>
            <category><![CDATA[wwdc]]></category>
            <category><![CDATA[xcode]]></category>
            <dc:creator><![CDATA[kyuchulkim]]></dc:creator>
            <pubDate>Thu, 06 Feb 2025 01:17:49 GMT</pubDate>
            <atom:updated>2025-02-06T01:19:35.008Z</atom:updated>
            <content:encoded><![CDATA[<h4><strong>SwiftUI 핵심 공부</strong></h4><h3>When SwiftUI looks at your code, What does it see?</h3><h4>Identity</h4><ul><li><strong>Identity는 SwiftUI가 앱의 여러번의 업데이트에서 요소(element)를 동일한 것으로, 혹은 다른 것으로 인식하는 방법 </strong>(뷰를 식별하는 방법)</li></ul><h4><strong>Lifetime</strong></h4><ul><li><strong>Lifetime은</strong> SwiftUI가 <strong>뷰와 데이터의 존재</strong>(existence)를 시간에 따라 <strong>추적</strong>하는 방법</li></ul><h4><strong>Dependency</strong></h4><ul><li><strong>Dependency는 SwiftUI가 인터페이스를 업데이트해야하는 시기와 그 이유를 이해하는 방법 </strong>(뷰에 필요한 데이터 + 데이터를 통해 뷰를 업데이트 하는 방법)</li></ul><h3>Identity</h3><h4>Types of identity</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/1*7Ds1oLq-oT3_u66Z9Fxh5Q.png" /></figure><p><strong>Explicit Identity (명시적 id)</strong></p><ul><li>사용자 정의 또는 데이터 기반 identity를 사용</li></ul><p><strong>Structural Identity (구조적 id)</strong></p><ul><li>view hierarchy 에서 타입 및 위치에 따라 뷰를 구분</li></ul><h4>Explicit Identity (명시적 id)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E0KAwcGXCp5mUqZPhhQOFw.png" /></figure><ul><li><strong>Explicit Identity</strong> 의 한가지 예시는 UIKit과 AppKit에서 사용중인 <strong>Pointer identity</strong></li><li>UIView 와 NSView 는 Reference Type 인 Class 이기 때문에 각각 메모리에 할당에 대한 고유한 포인터가 있음</li><li>포인터를 사용하여 개별 뷰를 참조할 수 있으며 여러 뷰가 동일한 포인터를 공유하는 경우 실제로 같은 뷰임을 보장</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SmK6P6m0rqMUFHRU0_M0sA.png" /></figure><ul><li>그러나 SwiftUI는 기본적으로 Value Type 인 Struct 구조로 이루어져 있다. → <strong>포인터를 사용하지 않는다.</strong></li><li>SwiftUI에서 Value Type을 사용하는 이유는 WWDC 2019 ‘SwiftUI essentials’에 나온다.</li></ul><h4>SwiftUI에서 View 를 Value Type으로 사용하는 이유</h4><p>Not allocated, no pointers (할당되지 않으며, 포인터를 사용하지 않는다.)</p><ul><li>값 타입(Value Type)은 스택(Stack)에 저장되며, 힙(Heap)에 메모리를 할당하지 않는다.</li><li>포인터를 사용하지 않기 때문에, 메모리 관리 오버헤드가 없고, 참조 카운팅(reference counting)이 필요하지 않다.</li></ul><p>Efficient memory representation (효율적인 메모리 표현 방식)</p><ul><li>값 타입은 불변성(immutability)을 기반으로 동작 이는 데이터가 변경될 때마다 새로운 복사본을 생성되므로 View가 변경되더라도 기존 뷰가 변경되지 않고 새로운 View가 생성</li><li>레이스 컨디션(Race Condition) 문제를 발생시키지 않으며, 멀티스레드 환경에서도 안전하다.</li><li>값 타입은 데이터의 독립성을 보장하므로, 예기치 않은 부작용(side effect)을 방지</li></ul><p>Supports small, single-purpose components (작고 단일 목적의 구성 요소를 지원)</p><ul><li>구조체는 <strong>값 자체를 복사(copy-on-write)</strong> 하여 전달하므로, 작은 View 컴포넌트들을 조합하는 방식에 적합</li><li>뷰가 상태(State)에 따라 달라질 때마다 새로운 값이 만들어지고, 변경된 부분만 다시 렌더링되므로 성능 최적화</li></ul><h4>Explicit Identity (명시적 id)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3Nprp5563L60mdvYr1S9bQ.png" /></figure><ul><li>대신, SwiftUI는 다른 형태의 <strong>Explicit Identity (명시적 id)에 의존한다.</strong></li><li>위의 예시를 보면 dogTagID id는 Explicit Identity의 형태 중 하나로 List에서 View를 명시적으로 식별하는데 사용</li><li>만약 목록(List)에서 id 값이 변경되면 해당 id 값을 활용해 무엇이 변경되었는지 파악하고 올바른 애니메이션을 생성시킨다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MLGMZYJys4WfvSuDPzPWlw.png" /></figure><ul><li><strong>id(_:) modifier</strong> 을 사용해서 <strong>custom identifier을 설정</strong>할 수도 있다.</li><li>해당 id 값을 ScrollViewReader Proxy의 scrollTo 메소드로 전달해 해당 ID 값의 뷰로 스크롤 되도록 할 수 있다.</li><li>주목할 점은 HeaderView 와 같이 다른 곳에서 참조할 element를 제외하고는 <strong>모든 뷰를 명시적으로 식별할 필요가 없다</strong>는 것</li><li>명시적이지 않았다고 해서 뷰의 identity가 없다는 것을 의미하는 것은 아님 → <strong>모든 뷰는 identity가 존재(Every View has an identity)</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ydkiO1jLj82qRGFgoLgCcg.png" /></figure><ul><li>SwiftUI는 <strong>뷰 hierarchy 를 사용</strong>하여, 뷰에 대한 <strong>implicit identitiy(암시적 id)를 생성</strong></li><li>이것이 바로 다음으로 설명할 <strong>structural identity (구조적 id)</strong></li></ul><h4>Structural Identity (구조적 id)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*R6iyJPbPPj8KFycF556n9g.png" /></figure><ul><li>SwiftUI는 API 전반에 걸쳐 <strong>Structural Identity를 사용한다. 일반적인 가장 좋은 예는</strong> View 코드에서 <strong>if 와 같은 조건부 로직</strong>을 사용하는 경우</li><li>조건문의 구조는 각 뷰를 식별하는 명확한 방법을 제공 (True 일 때는 AdoptionDirectory가 False 일 때는 DogList가 표시)</li><li>그러나 이 기능은 SwiftUI가 view들이 해당 <strong>위치에 계속 stay</strong>하고, <strong>자리를 변경(swap)하지 않을 것</strong> 이라는 사실을 SwiftUI가 <strong>정적으로 보장</strong>할 수 있을 때만 작동 그리고 SwiftUI는 view hierarchy의 <strong>type 구조를 확인</strong>하여 이 작업을 수행</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_Fo0FjJuKh2cI_MMl8Xh9g.png" /></figure><ul><li>내부적으로 볼 때 참/거짓 content 정보를 가진 <strong>하나의 generic view</strong> 인 _ConditionalContent 로 <strong>변환</strong></li><li>이 변환은 Swift의 result builder 유형인 <strong>ViewBuilder를 통해 수행</strong></li><li>참고로 View protocol에서는 body property를 ViewBuilder에 암시적으로 래핑하기 때문에 우리가 따로 명시하지 않아도 됨</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ksq2reaOKDtjM9tUmB4AFA.png" /></figure><ul><li>generic type 인 _ConditionalContent&lt;TrueContent, FalseContent&gt; 를 사용하여 SwiftUI는 true일때는 AdoptionDirectory 가 false일 때는 항상 DogList 라는 것을 보장 → 위에서 얘기한 뷰에 대한 <strong>implicit identitiy(암시적 id)를 안정적으로 할당</strong></li><li>SwfitUI는 if문의 분기가 고유한 id를 가지는 다른 뷰를 나타내는 것을 이해</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1018/1*Ozmc3couXZSRxl0MklPZHA.png" /></figure><ul><li>SwiftUI는 일반적으로 두번째 방식인 단일ID를 유지하고 유연한 전환을 제공하는 방식을 권장</li><li>if문의 분기의 경우 뷰의 수명과 상태를 보존하는게 어렵다. (if문에 따라 identity를 가진 뷰가 사라지고 다시 생성되기 때문)</li><li>두 번째 방식의 경우 뷰의 라이프타임은 계속 유지되면서(단일ID가 유지) viewModifier를 통해 유연한 전환을 제공</li></ul><h4>Evil nemesis AnyView</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jxn2fbtJ-KOvrgzgScnjVg.png" /></figure><ul><li><strong>AnyView를 사용하는 것은 지양해야 한다. (ViewBuilder을 사용하지 않으면, return Type이 맞지 않아 오류를 발생)</strong></li><li>AnyView를 사용하면 코드 가독성 저하, AnyView는 컴파일러에서 static type 정보를 숨기기 때문에 도움이 되는 에러나 경고 파악 불가, 퍼포먼스 저하가 발생할 수 있다.</li><li>AnyView 대신 generic 사용을 지향</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m7XTRKlCXRE4cIIogFnI1Q.png" /></figure><ul><li>switch문을 사용하여 코드 가독성을 더욱 높일 수 있음 (Best)</li></ul><h4>Identity 정리</h4><ul><li><strong>Identity는 SwiftUI가 앱의 여러번의 업데이트에서 요소(element)를 동일한 것으로, 혹은 다른 것으로 인식하는 방법 (view identity의 구분</strong>에 따라 인터페이스가 한 상태에서 다른 상태로 <strong>전환되는 방식을 변화)</strong></li><li><strong>Explicit identity:</strong> 뷰의 <strong>identity를 데이터에 연결</strong>하거나, <strong>특정 뷰를 참조</strong>할 수 있도록 <strong>custom identifier를 제공</strong>하는 방법</li><li><strong>Structural identity:</strong> SwiftUI가 view hierarchy 내에서 <strong>타입 및 위치를 기준으로 view 식별</strong></li></ul><h3>Lifetime</h3><ul><li>view의 identity가 어떤식으로 view와 data(state)의 수명에 관련되어있는지 알아본다.</li></ul><h4>View value ≠ View Identity</h4><ul><li>테세우스(identity)라는 고양이가 있다. 해당 고양이가 시간에 따라 상태(State)가 변경 될 수 있다. (배고픔, 졸림, 신남) 그러나! ‘테세우스’라는 같은 고양이인 것에는 변함이 없다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kJt0oyud_gToSl1f9JvgGg.png" /></figure><ul><li><strong>위의 예시처럼 State(Value)가 변화하는거지 identity가 변하는 것은 아니다. → view의 identity와 lifetime을 연결하는 본질(essence)</strong></li><li>테세우스 처럼 view는 <strong>identity가 동일하다면 state(value)가 달라도 동일한 view로 인식</strong></li><li>identity를 사용하면 시간에 따라 변화하는 다양한 Value를 안정적으로 정의 가능 → 연속성을 가진다.</li><li>즉, SwiftUI에서 View의 Lifetime은 identity의 지속 기간이다. → View의 id가 유지되고 있느냐가 View의 lifetime</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0teTayzLCnV2sXTyQMGtlQ.png" /><figcaption>intensity 값이 25 -&gt; 50으로 변화</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sW79fmX6HAKm6XS0jj8uTQ.png" /><figcaption>50으로 변화 후 기존 값을 파괴</figcaption></figure><ul><li>PurrDecibelView(intensity: 25) 가 생성되고 나중에 PurrDecibelView(intensity: 50) 이 생성</li><li>SwiftUI는 비교를 위해 값(value)의 사본을 유지하고 있다가 값을 비교한 뒤 기존의 값을 파괴 시킨다.</li><li>여기서 주목해야할 점은 view value와 view identity는 다르다는 것 (view의 Value가 변경되어도 View는 파괴되지 않는다.)</li><li>view value는 일시적이기 때문에 view lifetime에 의존해선 안됨</li></ul><h4>A View’s lifetime is the duration of the identity</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lZ76wTgcM3-vfPlaTFGM0w.png" /></figure><ul><li>view가 처음 <strong>생성(created)되고 나타날(onAppear)</strong> 때 SwiftUI는 <strong>Explicit or Structural Identity를 통해 view에 Identity을 설정한다.</strong></li><li>시간이 지남에 따라, view 에 <strong>새로운 값(value)들이 생성</strong>(state 값이 변경되는 것) 그러나 SwiftUI 관점에서는 여전히 <strong>동일한 view</strong>(같은 identity를 가지기 때문).</li><li>view의 identity 값이 변경되거나 <strong>view가 제거</strong>(removed)될 때 (onDisappear) view의 수명은 끝난다. → <strong>따라서 view 의 수명은 identity의 지속 시간과 연관</strong></li></ul><h4>State lifetime = View lifetime</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*il3BG_s625A__kxnArL1Tw.png" /></figure><ul><li>SwiftUI가 view에서 @state, @stateObject 를 보면 해당 데이터를 view의 lifetime 동안 유지해야한다는것을 인식</li><li>State와 StateObject는 view의 <strong>identiy와 연결된 영구적인 저장소</strong>(persistent storage)</li><li>view의 Identity가 처음 생성될 때(뷰가 처음 생성될 때) SwiftUI는 State 및 StateObject의 <strong>초기 값을 사용</strong>하여 메모리에 저장소(storage)를 <strong>할당</strong></li><li>title state 를 예시로 보면 SwiftUI는 storage가 변경(mutated)되어 view의 body가 재호출(re-evaluated)되어도 view의 lifetime동안 storage를 유지(persist)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NsqfR0xJtVJEyn8EH6iz6w.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xc-8QYMqcKhfDW5Xxn_hdg.png" /></figure><ul><li>다음과 같이 identity가 변경되는 방식으로 새로운 뷰가 생성된다면, 기존 View에 대한 storage는 파괴되고, state의 초기 값에서 다시 새로운 storage를 만든다.</li><li>daytime이 false로 변경되면 새로운 id를 가진 View가 되므로, 이전 View는 메모리에서 해제되고 새로운 메모리를 할당</li><li>즉 identity가 바뀔때마다 state는 대체(replace)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*di9nB-YsqB_RIPsMSy42OQ.png" /></figure><ul><li>identity가 바뀌면 state(storage)가 교체 (identity는 view의 lifetime) → state의 persistence는 View의 lifetime과 연관이 있다.</li></ul><h4>Lifetime 정리</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/982/1*vLdsfuzq1SfZ5ewUC-mSAA.png" /></figure><ul><li>View Value는 임시적인 데이터이기 때문에 그것의 수명에 의존해선 안된다. → State는 매우 자주 변경 된다.</li><li>View의 identity는 일시적이지 않기에 시간이 지나도 View의 연속성을 제공</li><li>개발자는 View의 identity를 컨트롤이 가능하고, 이를 사용하여 View의 수명을 명확하게 할 수 있다.</li><li>SwiftUI는 Identifiable 프로토콜을 최대한 활용하므로, 데이터에 대한 안정적인 identifier를 선택하는게 중요 (Identifiable를 잘 활용해라? → 해당 id는 안정적이기 때문)</li></ul><h3>Dependency</h3><ul><li>SwiftUI가 어떻게 UI를 업데이트하는지에 대해 다이빙 할 것이다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HqqWnrjH8h5lrLFnzvfVYw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rwG0kEUHQyRyO3w-BiwVQw.png" /></figure><ul><li>Dependency는 단순히 View에 대한 input일 뿐이다.</li><li>Dependency가 변경되면 View는 새로운 body를 생성해야 한다.</li><li>body는 View hierachy를 빌드하는 곳이고, action은 View의 <strong>dependency에 대한 변경을 트리거 하는 것</strong></li></ul><h4>Dependency Graph</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/938/1*mP0hjdOiv63nRAVz1Om7Pg.png" /></figure><ul><li>body가 초록색 hierarchy로 표현, 가장 상위 뷰에 대한 dependency가 파란색 dog과 treat로 표현 (tree 형태로 보임)</li><li>이때 각 View는 각자의 dependency 목록을 가질 수 있다. DogView 뿐만 아니라 다른곳에서도 dependency가 추가될 수 있음</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5QW5aqiw7P0f_qa05pQ1Sw.png" /></figure><ul><li>동일한 state나 data에 다수의 뷰가 의존 할 수도 있다.</li><li>위에선 tree로 보일 수도 있지만 현재는 view와 dependency의 관계를 <strong>graph로 볼 수 있다. → 이러한 구조를 Dependency Graph</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/962/1*ucl0hrEaQu2XHHSjflwbjQ.png" /></figure><ul><li>SwiftUI는 그래프를 통해 새로운 body가 필요한 View가 무엇인지 파악 후 효율적 업데이트 한다.</li><li>가장 하단의 dependency를 예를 들면 이 dependency에 영향을 받는 View는 2개가 있다.</li><li>dependency가 변경되면 dependency에 영향을 받는 뷰만 무효화 시킴</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rnbTMhtytWdmSyFpKHNVug.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sKGY5JRtIvqpMBND-vIXPQ.png" /></figure><ul><li>SwiftUI는 각 무효화된 View의 body를 호출하여 각 View에 대한 새로운 body value를 인스턴스화 한다.</li><li>이로 인해 무효화된 View와 연관된 더 많은 dependency가 변경 될 수 있지만 항상 그런 것은 아니다. View는 값 타입이기 때문에 SwiftUI는 효율적으로 비교하여 올바른 하위 View만 업데이트 시킴</li><li>정리하자면 빨간색 Dependency가 변하면 해당 Dependency가 연결된 두개의 View의 Body만 재계산 → 이후 생성된 body를 통해 새 View도 업데이트 되어야 하는지 판단</li><li><strong>View의 value(struct)는 수명이 짧아 값 비교에만 사용되지만 View 자체 수명은 이보다 길다.</strong></li></ul><h4>Dependency In Explicit Identity</h4><ul><li>모든 View는 <strong>명시적(Explicit)</strong> 또는 <strong>구조적(Structural)</strong> identity를 가지고 있음</li><li>identity는 dependency graph의 핵심 identity를 통해 SwiftUI가 변경사항을 올바른 View로 라우팅하고 UI를 효율적으로 업데이트 할 수 있음</li><li>명시적으로 Identity를 설정할때 고려해야할 것은 Identity의 stability(안정성)와 <strong>uniquness(고유성)</strong></li></ul><h4>Identifier stability</h4><ul><li><strong>identifier가 안정적이면, View에 대한 Storage를 지속적으로 생성(SwiftUI는 뷰의 상태를 유지하기 위해 View마다 관련 데이터를 저장하는 Storage를 내부적으로 관리, </strong><strong>@State, </strong><strong>@Binding, </strong><strong>@ObservedObject 같은 프로퍼티 래퍼들은 Storage에 저장됨)하거나 dependency graph</strong> 를 업데이트하지 않아도 되기 때문에 퍼포먼스 측면에서 도움</li><li>SwiftUI는 identity를 사용하여 persisted storage를 관리하기 때문에 state 손실 방지에도 도움(View의 lifetime = state lifetime)</li></ul><h4>Example of Explicit identity</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NQvvBWvIq0v3I3-6nizgMQ.png" /></figure><ul><li>id를 UUID()로 초기화 해주는 이슈가 존재하는 코드다</li><li>데이터가 변경될 때마다 새로운 id를 얻기 때문에 안정적이지 않음</li><li>id 값을 컴퓨티드 프로퍼티로 두면, Pet을 가져올때마다 id가 변하기 때문에 리스트의 View 전부가 모두 다시 계산되어 깜박거리는 현상이 발생</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iQMnshVngpmSAaRuAzNuXA.png" /></figure><ul><li>indicies를 사용해서 index를 사용하는 것도 안정적이지 않음</li><li>index는 데이터의 추가, 삭제, 이동에 의해 변경될 수 있기 때문이다.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s7prgd19FztY0A7R3uFxpQ.png" /></figure><ul><li>dataBaseID 같은 영구적인 identifier를 쓰는 것이 Best다</li></ul><h4>Identifier uniquness</h4><ul><li>좋은 <strong>Identifier의 다른 특성은 uniquness(고유성)이다.</strong></li><li>각각의 identity는 단 하나의 뷰(single view)에만 매핑 되어야 함 (1:1 매치)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J_KttmpkwwoGglgaPGAOaA.png" /></figure><ul><li>name은 unique하지 않기 때문에 id로는 적합하지 않음</li></ul><pre>struct ContentView: View {<br>    struct Item {<br>        let name: String<br>    }<br><br>    let items = [<br>        Item(name: &quot;Apple&quot;),<br>        Item(name: &quot;Banana&quot;),<br>        Item(name: &quot;Apple&quot;) // 중복된 name!<br>    ]<br><br>    var body: some View {<br>        List {<br>            ForEach(items, id: \\.name) { item in<br>                Text(item.name)<br>            }<br>        }<br>    }<br>}</pre><ul><li>SwiftUI가 같은 id를 가진 View가 이미 존재한다고 판단하여 <strong>잘못된 View를 재사용</strong></li><li>id가 중복되면 SwiftUI가 View 간의 차이를 감지하는 데 실패하여 <strong>애니메이션이 깨질 수 있음</strong>. (리스트에서 아이템을 추가/삭제할 때 올바른 애니메이션이 적용되지 않을 수 있음.)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RLwxX0WSS2B4SUFWopdZLw.png" /></figure><ul><li>serialNumber 같은 시리얼 넘버 같은건 unique 한 값을 사용하는 것이 더 나은 애니메이션과 퍼포먼스를 보장</li></ul><h4>Explicit identity의 주의점</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/730/1*LW6HZJcjmUGhkLLeN2gojQ.png" /></figure><ul><li>계산 속성(컴퓨티드 프로퍼티)에서 random identifier(ex: UUID())를 사용할 때는 주의</li><li>identity는 시간이 지나도 변경되어선 안됨</li><li>새로운 identity는 새로운 lifetime을 가지는 새로운 item</li><li>identity는 고유해야함 identity를 공유하면 안됨</li></ul><h4>Dependency In Structured Identity</h4><ul><li>Explicit identit 에서는 stability와 uniquness 를 고려한 것처럼, Structural identity 에서는 어떤 사항을 고려해야 하나?</li></ul><h4>Example of Structural Identity</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mGZI4qYPW99-S0lVF0uyyA.png" /></figure><ul><li>if 분기처리로 view가 분기되어 있다. 따라서 각 view 는 다른 identifier를 가진 2개의 View로 취급된다.</li><li>View마다 id 값이 달라지기 때문에 뷰가 파괴되고 새로 생성되는 문제가 발생할 수 있다. (State 손실)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w3kD-oXAN3h8thn61-HMiA.png" /></figure><ul><li>다음과 같이 modifier를 활용하면 single identity의 동일한 view 1개를 사용 할 수 있다.</li><li>SwiftUI의 modifier은 매우 저렴</li><li>브랜치(if로 뷰 분기)를 불필요하게 사용할 경우 성능이 저하</li></ul><h4>Structural Identity의 주의점</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*CxqNd97yb5ZAta3NQ65q-w.png" /></figure><ul><li>브랜치를 불필요하게 사용할 경우 성능이 저하, 의도치 않은 애니메이션, state 손실 등이 발생</li><li>branch 도입 시에는 여러 view를 나타내는지 아니면 단일 view의 다른 state를 나타내는지 것인지 고려</li><li>단일 view를 나타내는 것이라면 보통은 modifier을 사용하는 것이 Best</li></ul><p><strong><em>SwiftUI에서는 명확하고 구조적인 identity를 설정하는 것이 좋은 성능을 위한 비결 중 하나</em></strong></p><p><a href="https://developer.apple.com/videos/play/wwdc2021/10022/">https://developer.apple.com/videos/play/wwdc2021/10022/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9842c3d38203" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>