Chaos and Order

💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

1. 왜 네이티브 개발인가?

2026년 현재, React Native, Flutter, KMP(Kotlin Multiplatform) 같은 크로스 플랫폼 솔루션이 성숙해졌음에도 불구하고 네이티브 개발의 중요성은 여전히 절대적이다. 고성능 게임, 카메라/AR 앱, 시스템 API 깊이 활용, 최신 OS 기능 즉시 채택이 필요한 모든 시나리오에서 네이티브가 우위를 점한다.

네이티브 vs 크로스 플랫폼 의사결정 매트릭스

기준	네이티브 추천	크로스 플랫폼 추천
성능 요구사항	60fps+ 게임, AR/VR	일반 비즈니스 앱
플랫폼 API 활용	HealthKit, ARKit, CarPlay	기본 카메라, 위치
팀 규모	큰 팀 (iOS/Android 분리)	작은 팀 (1코드베이스)
출시 속도	점진적, 품질 우선	빠른 MVP, 동시 출시
OS 신기능 즉시 채택	중요 (Liquid Glass, Live Activities)	후순위
앱 크기	작게 유지 가능	런타임 오버헤드
UX 일관성	플랫폼별 디자인 가이드 준수	단일 디자인 시스템

2026년 네이티브 개발 환경

iOS 18, Swift 6.1, Xcode 16
Android 15, Kotlin 2.0, Android Studio Ladybug
SwiftUI 6 + UIKit interop 강화
Jetpack Compose 1.7 + Material 3 Expressive

2. Swift 6: 컴파일 타임 안전성의 새 시대

Swift 6은 2024년 9월 출시된 메이저 버전으로, strict concurrency가 기본값이 되어 데이터 레이스를 컴파일 타임에 잡아낸다.

2.1 Strict Concurrency Mode

// Swift 6: 데이터 레이스 컴파일 에러
class Counter {
    var value = 0  // ⚠️ Sendable이 아님

    func increment() {
        value += 1
    }
}

// 여러 Task에서 동시 접근 시 컴파일 에러
Task {
    let counter = Counter()
    Task { counter.increment() }  // ❌ Error
    Task { counter.increment() }
}

// 해결책 1: actor 사용
actor Counter {
    var value = 0
    func increment() {
        value += 1
    }
}

// 해결책 2: @MainActor 격리
@MainActor
class Counter {
    var value = 0
    func increment() {
        value += 1
    }
}

2.2 Typed Throws

// Swift 5: throws만 가능, 어떤 에러인지 알 수 없음
func loadData() throws -> Data {
    throw NetworkError.timeout
}

// Swift 6: 특정 에러 타입 명시 가능
enum NetworkError: Error {
    case timeout
    case noConnection
    case serverError(Int)
}

func loadData() throws(NetworkError) -> Data {
    throw .timeout
}

// 호출부에서 정확한 타입 매칭
do {
    let data = try loadData()
} catch .timeout {
    print("Timeout")
} catch .serverError(let code) {
    print("Server error: \(code)")
}

2.3 Embedded Swift

리소스 제약이 심한 환경 (마이크로컨트롤러, 임베디드)에서 Swift를 사용 가능. 메타데이터/리플렉션 제거, ARC만 사용. iOS 위젯, watchOS 같은 메모리 제약 환경에서도 활용.

// Embedded Swift 예시: 리플렉션 없이 동작
@_silgen_name("led_on")
func ledOn()

@main
struct MyApp {
    static func main() {
        while true {
            ledOn()
        }
    }
}

3. Kotlin 2.0: K2 컴파일러의 성능 혁명

Kotlin 2.0은 K2 컴파일러를 기본으로 채택하여 컴파일 속도가 최대 2배 빨라졌다.

3.1 K2 컴파일러 주요 변경점

// Smart cast 개선: 더 똑똑해진 타입 추론
fun process(input: Any?) {
    if (input is String && input.isNotEmpty()) {
        // K2: input이 String임을 lambda 안에서도 인식
        listOf(1, 2, 3).forEach {
            println(input.length)  // ✅ K1에서는 에러
        }
    }
}

// 데이터 클래스 copy 개선
data class User(val name: String, val age: Int)

val user = User("Alice", 30)
val updated = user.copy(age = 31)

3.2 Kotlin Multiplatform (KMP) Stable

// commonMain: 공통 비즈니스 로직
class UserRepository(private val api: UserApi) {
    suspend fun getUser(id: String): User = api.fetchUser(id)
}

// iosMain: iOS 전용 구현
actual class Platform {
    actual val name: String = "iOS ${UIDevice.currentDevice.systemVersion}"
}

// androidMain: Android 전용 구현
actual class Platform {
    actual val name: String = "Android ${Build.VERSION.SDK_INT}"
}

3.3 Coroutines 1.9 + Flow

// Structured Concurrency
class UserViewModel : ViewModel() {
    private val _state = MutableStateFlow<UiState>(UiState.Loading)
    val state: StateFlow<UiState> = _state.asStateFlow()

    fun loadUser(id: String) {
        viewModelScope.launch {
            try {
                val user = userRepository.getUser(id)
                _state.value = UiState.Success(user)
            } catch (e: Exception) {
                _state.value = UiState.Error(e.message ?: "Unknown")
            }
        }
    }
}

// Flow 변환
class SearchViewModel : ViewModel() {
    private val query = MutableStateFlow("")

    val results: StateFlow<List<Item>> = query
        .debounce(300)
        .distinctUntilChanged()
        .filter { it.length >= 2 }
        .flatMapLatest { searchRepository.search(it) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())
}

4. SwiftUI Deep Dive

4.1 View 프로토콜과 선언형 패러다임

import SwiftUI

struct ContentView: View {
    @State private var counter = 0
    @State private var name = ""

    var body: some View {
        VStack(spacing: 20) {
            Text("Hello, \(name.isEmpty ? "World" : name)!")
                .font(.largeTitle)
                .foregroundStyle(.primary)

            TextField("Enter name", text: $name)
                .textFieldStyle(.roundedBorder)
                .padding(.horizontal)

            Button("Increment: \(counter)") {
                counter += 1
            }
            .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}

4.2 State Management

// @State: 로컬 값 타입 상태
struct LocalStateView: View {
    @State private var isOn = false

    var body: some View {
        Toggle("Switch", isOn: $isOn)
    }
}

// @Binding: 부모 상태에 대한 양방향 바인딩
struct ChildView: View {
    @Binding var value: String

    var body: some View {
        TextField("Input", text: $value)
    }
}

// @Observable (iOS 17+): 새로운 옵저버블 매크로
@Observable
class UserStore {
    var users: [User] = []
    var isLoading = false

    func fetchUsers() async {
        isLoading = true
        defer { isLoading = false }
        users = await api.getUsers()
    }
}

struct UserListView: View {
    @State private var store = UserStore()

    var body: some View {
        List(store.users) { user in
            Text(user.name)
        }
        .task {
            await store.fetchUsers()
        }
    }
}

// @Environment: 환경 값 주입
struct ThemedView: View {
    @Environment(\.colorScheme) var colorScheme

    var body: some View {
        Text("Current: \(colorScheme == .dark ? "Dark" : "Light")")
    }
}

4.3 Animation과 Transition

struct AnimatedView: View {
    @State private var isExpanded = false

    var body: some View {
        VStack {
            RoundedRectangle(cornerRadius: 16)
                .fill(.blue.gradient)
                .frame(
                    width: isExpanded ? 300 : 100,
                    height: isExpanded ? 200 : 100
                )
                .animation(.spring(response: 0.5, dampingFraction: 0.7), value: isExpanded)
                .onTapGesture {
                    isExpanded.toggle()
                }

            // Phased animations (iOS 17+)
            Image(systemName: "heart.fill")
                .symbolEffect(.bounce, value: isExpanded)
                .foregroundStyle(.red)
                .font(.system(size: 60))
        }
    }
}

4.4 NavigationStack (iOS 16+)

struct AppNavigation: View {
    @State private var path = NavigationPath()

    var body: some View {
        NavigationStack(path: $path) {
            List {
                NavigationLink("Profile", value: Route.profile)
                NavigationLink("Settings", value: Route.settings)
            }
            .navigationDestination(for: Route.self) { route in
                switch route {
                case .profile:
                    ProfileView()
                case .settings:
                    SettingsView()
                case .detail(let id):
                    DetailView(id: id)
                }
            }
        }
    }
}

enum Route: Hashable {
    case profile
    case settings
    case detail(id: String)
}

5. Jetpack Compose Deep Dive

5.1 Composable 함수 기초

@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
    Text(
        text = "Hello, $name!",
        modifier = modifier.padding(16.dp),
        style = MaterialTheme.typography.headlineMedium
    )
}

@Composable
fun ContentScreen() {
    var counter by remember { mutableStateOf(0) }
    var name by remember { mutableStateOf("") }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        verticalArrangement = Arrangement.spacedBy(16.dp)
    ) {
        Text(
            text = "Hello, ${name.ifEmpty { "World" }}!",
            style = MaterialTheme.typography.headlineLarge
        )

        OutlinedTextField(
            value = name,
            onValueChange = { name = it },
            label = { Text("Enter name") },
            modifier = Modifier.fillMaxWidth()
        )

        Button(
            onClick = { counter++ },
            modifier = Modifier.fillMaxWidth()
        ) {
            Text("Increment: $counter")
        }
    }
}

5.2 State Hoisting

// State hoisting: 상태를 호출자에게 위임
@Composable
fun StatefulCounter() {
    var count by remember { mutableStateOf(0) }
    StatelessCounter(
        count = count,
        onIncrement = { count++ }
    )
}

@Composable
fun StatelessCounter(
    count: Int,
    onIncrement: () -> Unit
) {
    Button(onClick = onIncrement) {
        Text("Count: $count")
    }
}

5.3 Side Effects

@Composable
fun UserScreen(userId: String, viewModel: UserViewModel) {
    val state by viewModel.state.collectAsStateWithLifecycle()

    // LaunchedEffect: composition 진입 시 실행
    LaunchedEffect(userId) {
        viewModel.loadUser(userId)
    }

    // DisposableEffect: 리소스 정리
    DisposableEffect(Unit) {
        val listener = LocationListener()
        locationManager.addListener(listener)
        onDispose {
            locationManager.removeListener(listener)
        }
    }

    when (val s = state) {
        is UiState.Loading -> CircularProgressIndicator()
        is UiState.Success -> UserDetail(s.user)
        is UiState.Error -> ErrorView(s.message)
    }
}

5.4 Navigation Compose

@Composable
fun AppNavHost() {
    val navController = rememberNavController()

    NavHost(
        navController = navController,
        startDestination = "home"
    ) {
        composable("home") {
            HomeScreen(
                onNavigateToProfile = { navController.navigate("profile") },
                onNavigateToDetail = { id -> navController.navigate("detail/$id") }
            )
        }
        composable("profile") {
            ProfileScreen()
        }
        composable(
            route = "detail/{id}",
            arguments = listOf(navArgument("id") { type = NavType.StringType })
        ) { backStackEntry ->
            val id = backStackEntry.arguments?.getString("id") ?: ""
            DetailScreen(id = id)
        }
    }
}

6. 아키텍처 패턴

6.1 MVVM (Model-View-ViewModel)

iOS와 Android 모두에서 가장 보편적으로 사용되는 패턴.

// iOS MVVM
@Observable
class ProductListViewModel {
    var products: [Product] = []
    var isLoading = false
    var error: String?

    private let repository: ProductRepository

    init(repository: ProductRepository) {
        self.repository = repository
    }

    func loadProducts() async {
        isLoading = true
        error = nil
        do {
            products = try await repository.fetchProducts()
        } catch {
            self.error = error.localizedDescription
        }
        isLoading = false
    }
}

struct ProductListView: View {
    @State private var viewModel: ProductListViewModel

    init(repository: ProductRepository) {
        _viewModel = State(initialValue: ProductListViewModel(repository: repository))
    }

    var body: some View {
        Group {
            if viewModel.isLoading {
                ProgressView()
            } else if let error = viewModel.error {
                Text("Error: \(error)")
            } else {
                List(viewModel.products) { product in
                    ProductRow(product: product)
                }
            }
        }
        .task {
            await viewModel.loadProducts()
        }
    }
}

// Android MVVM with Hilt
@HiltViewModel
class ProductListViewModel @Inject constructor(
    private val repository: ProductRepository
) : ViewModel() {

    private val _state = MutableStateFlow<UiState>(UiState.Loading)
    val state: StateFlow<UiState> = _state.asStateFlow()

    init {
        loadProducts()
    }

    fun loadProducts() {
        viewModelScope.launch {
            _state.value = UiState.Loading
            try {
                val products = repository.fetchProducts()
                _state.value = UiState.Success(products)
            } catch (e: Exception) {
                _state.value = UiState.Error(e.message ?: "Unknown")
            }
        }
    }
}

@Composable
fun ProductListScreen(viewModel: ProductListViewModel = hiltViewModel()) {
    val state by viewModel.state.collectAsStateWithLifecycle()

    when (val s = state) {
        is UiState.Loading -> CircularProgressIndicator()
        is UiState.Error -> Text("Error: ${s.message}")
        is UiState.Success -> LazyColumn {
            items(s.products) { product ->
                ProductRow(product)
            }
        }
    }
}

6.2 The Composable Architecture (TCA) - iOS

Point-Free의 TCA는 Redux 영감을 받은 단방향 데이터 흐름 아키텍처.

import ComposableArchitecture

@Reducer
struct CounterFeature {
    @ObservableState
    struct State: Equatable {
        var count = 0
        var fact: String?
        var isLoading = false
    }

    enum Action {
        case incrementButtonTapped
        case decrementButtonTapped
        case factButtonTapped
        case factResponse(String)
    }

    @Dependency(\.numberFactClient) var numberFact

    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .incrementButtonTapped:
                state.count += 1
                return .none

            case .decrementButtonTapped:
                state.count -= 1
                return .none

            case .factButtonTapped:
                state.isLoading = true
                return .run { [count = state.count] send in
                    let fact = try await numberFact.fetch(count)
                    await send(.factResponse(fact))
                }

            case let .factResponse(fact):
                state.fact = fact
                state.isLoading = false
                return .none
            }
        }
    }
}

struct CounterView: View {
    let store: StoreOf<CounterFeature>

    var body: some View {
        VStack {
            Text("Count: \(store.count)")
            HStack {
                Button("-") { store.send(.decrementButtonTapped) }
                Button("+") { store.send(.incrementButtonTapped) }
            }
            Button("Get Fact") { store.send(.factButtonTapped) }

            if store.isLoading {
                ProgressView()
            } else if let fact = store.fact {
                Text(fact)
            }
        }
    }
}

6.3 Clean Architecture

Presentation Layer (UI)
    ↓
Domain Layer (UseCases, Entities)
    ↓
Data Layer (Repositories, DataSources)

7. 비동기 처리: Swift Concurrency vs Coroutines

7.1 Swift Concurrency

// async/await 기본
func fetchUser(id: String) async throws -> User {
    let url = URL(string: "https://api.example.com/users/\(id)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(User.self, from: data)
}

// 병렬 실행: async let
func fetchUserData(id: String) async throws -> UserData {
    async let profile = fetchProfile(id: id)
    async let posts = fetchPosts(userId: id)
    async let followers = fetchFollowers(userId: id)

    return try await UserData(
        profile: profile,
        posts: posts,
        followers: followers
    )
}

// TaskGroup: 동적 병렬 처리
func fetchAllUsers(ids: [String]) async throws -> [User] {
    try await withThrowingTaskGroup(of: User.self) { group in
        for id in ids {
            group.addTask {
                try await fetchUser(id: id)
            }
        }

        var users: [User] = []
        for try await user in group {
            users.append(user)
        }
        return users
    }
}

// Actor: 동시성 안전한 상태 관리
actor BankAccount {
    private var balance: Decimal = 0

    func deposit(_ amount: Decimal) {
        balance += amount
    }

    func withdraw(_ amount: Decimal) throws -> Decimal {
        guard balance >= amount else {
            throw BankError.insufficientFunds
        }
        balance -= amount
        return amount
    }

    func getBalance() -> Decimal {
        balance
    }
}

// 사용
let account = BankAccount()
await account.deposit(100)
let balance = await account.getBalance()

7.2 Kotlin Coroutines

// 기본 코루틴
suspend fun fetchUser(id: String): User = withContext(Dispatchers.IO) {
    val response = httpClient.get("https://api.example.com/users/$id")
    Json.decodeFromString<User>(response.body())
}

// 병렬 실행: async/await
suspend fun fetchUserData(id: String): UserData = coroutineScope {
    val profile = async { fetchProfile(id) }
    val posts = async { fetchPosts(id) }
    val followers = async { fetchFollowers(id) }

    UserData(
        profile = profile.await(),
        posts = posts.await(),
        followers = followers.await()
    )
}

// Flow: reactive 스트림
class SearchViewModel : ViewModel() {
    private val queryFlow = MutableStateFlow("")

    val searchResults: Flow<List<Result>> = queryFlow
        .debounce(300)
        .filter { it.length >= 2 }
        .distinctUntilChanged()
        .mapLatest { query ->
            searchApi.search(query)
        }
        .catch { e ->
            emit(emptyList())
        }
}

// Channel: 코루틴 간 통신
fun produceNumbers(): ReceiveChannel<Int> = produce {
    for (i in 1..10) {
        send(i)
        delay(100)
    }
}

suspend fun consumeNumbers() = coroutineScope {
    val channel = produceNumbers()
    for (number in channel) {
        println(number)
    }
}

8. 의존성 주입

8.1 iOS - Swinject

import Swinject

let container = Container()

// 등록
container.register(NetworkService.self) { _ in
    NetworkServiceImpl(baseURL: "https://api.example.com")
}

container.register(UserRepository.self) { resolver in
    UserRepositoryImpl(network: resolver.resolve(NetworkService.self)!)
}

container.register(UserViewModel.self) { resolver in
    UserViewModel(repository: resolver.resolve(UserRepository.self)!)
}

// 사용
let viewModel = container.resolve(UserViewModel.self)!

8.2 Android - Hilt

@HiltAndroidApp
class MyApplication : Application()

@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    @Provides
    @Singleton
    fun provideRetrofit(): Retrofit = Retrofit.Builder()
        .baseUrl("https://api.example.com")
        .addConverterFactory(GsonConverterFactory.create())
        .build()

    @Provides
    @Singleton
    fun provideUserApi(retrofit: Retrofit): UserApi = retrofit.create(UserApi::class.java)
}

@HiltViewModel
class UserViewModel @Inject constructor(
    private val repository: UserRepository
) : ViewModel() {
    // ...
}

9. 테스팅

9.1 iOS - XCTest + Swift Testing

import Testing
@testable import MyApp

@Suite("UserViewModel Tests")
struct UserViewModelTests {

    @Test("Loading user updates state correctly")
    func loadUser() async throws {
        let mockRepo = MockUserRepository()
        mockRepo.userToReturn = User(id: "1", name: "Alice")

        let viewModel = UserViewModel(repository: mockRepo)
        await viewModel.loadUser(id: "1")

        #expect(viewModel.user?.name == "Alice")
        #expect(viewModel.isLoading == false)
    }

    @Test("Loading failure sets error", arguments: [
        NetworkError.timeout,
        NetworkError.noConnection
    ])
    func loadUserFailure(error: NetworkError) async throws {
        let mockRepo = MockUserRepository()
        mockRepo.errorToThrow = error

        let viewModel = UserViewModel(repository: mockRepo)
        await viewModel.loadUser(id: "1")

        #expect(viewModel.error != nil)
    }
}

9.2 Android - JUnit + Compose Testing

@RunWith(AndroidJUnit4::class)
class UserViewModelTest {
    @get:Rule
    val coroutineRule = MainCoroutineRule()

    private lateinit var viewModel: UserViewModel
    private lateinit var repository: FakeUserRepository

    @Before
    fun setup() {
        repository = FakeUserRepository()
        viewModel = UserViewModel(repository)
    }

    @Test
    fun `loadUser updates state to success`() = runTest {
        repository.userToReturn = User("1", "Alice")

        viewModel.loadUser("1")

        val state = viewModel.state.value
        assertTrue(state is UiState.Success)
        assertEquals("Alice", (state as UiState.Success).user.name)
    }
}

// Compose UI Test
@RunWith(AndroidJUnit4::class)
class UserScreenTest {
    @get:Rule
    val composeTestRule = createComposeRule()

    @Test
    fun userScreen_displaysUserName() {
        composeTestRule.setContent {
            UserScreen(user = User("1", "Alice"))
        }

        composeTestRule
            .onNodeWithText("Alice")
            .assertIsDisplayed()
    }
}

10. 성능 최적화

10.1 SwiftUI 최적화

// ❌ 잘못된 예: 매번 새로운 View 생성
struct BadView: View {
    var body: some View {
        VStack {
            ForEach(0..<1000) { i in
                ExpensiveView(index: i)
            }
        }
    }
}

// ✅ 좋은 예: LazyVStack 사용
struct GoodView: View {
    var body: some View {
        ScrollView {
            LazyVStack {
                ForEach(0..<1000) { i in
                    ExpensiveView(index: i)
                }
            }
        }
    }
}

// Equatable로 불필요한 재계산 방지
struct ExpensiveView: View, Equatable {
    let data: ComplexData

    static func == (lhs: ExpensiveView, rhs: ExpensiveView) -> Bool {
        lhs.data.id == rhs.data.id
    }

    var body: some View {
        // ...
    }
}

10.2 Compose 최적화

// Stable annotations
@Stable
data class UiState(
    val items: List<Item>,
    val isLoading: Boolean
)

// remember로 비싼 계산 캐싱
@Composable
fun ExpensiveCalculation(items: List<Item>) {
    val sortedItems = remember(items) {
        items.sortedBy { it.priority }
    }

    LazyColumn {
        items(sortedItems, key = { it.id }) { item ->
            ItemRow(item)
        }
    }
}

// derivedStateOf로 파생 상태 최적화
@Composable
fun ScrollableList() {
    val listState = rememberLazyListState()
    val showButton by remember {
        derivedStateOf { listState.firstVisibleItemIndex > 0 }
    }

    if (showButton) {
        FloatingActionButton(onClick = { /* scroll to top */ }) {
            Icon(Icons.Default.ArrowUpward, null)
        }
    }
}

11. 출시 프로세스

11.1 iOS App Store

Xcode Cloud / GitHub Actions로 CI/CD
TestFlight 베타 배포 (외부 100명, 내부 10000명)
App Store Connect:
- 앱 메타데이터 (제목, 설명, 키워드, 스크린샷)
- In-App Purchases 설정
- Privacy Manifest (PrivacyInfo.xcprivacy) 필수
App Review (평균 24-48시간)
Phased Release (7일에 걸쳐 점진적 배포)

11.2 Google Play

Gradle Play Publisher 또는 Fastlane
Internal Testing → Closed Testing → Open Testing → Production
Play Console:
- App Bundle (.aab) 업로드 필수
- Data Safety Form 작성
- Target API Level 34+ (Android 14)
Review (몇 시간 ~ 며칠)
Staged Rollout (1% → 10% → 50% → 100%)

12. 비교 정리표

항목	iOS (Swift/SwiftUI)	Android (Kotlin/Compose)
언어	Swift 6	Kotlin 2.0
UI 프레임워크	SwiftUI 6	Jetpack Compose 1.7
비동기	async/await + actor	coroutines + Flow
DI	Swinject, Factory	Hilt, Koin
테스트	XCTest, Swift Testing	JUnit, Compose Testing
빌드 시스템	Xcode, SPM	Gradle
패키지 관리	SPM, CocoaPods	Maven, Gradle
CI/CD	Xcode Cloud, Fastlane	GitHub Actions, Fastlane
출시	App Store Connect	Play Console
최소 OS	iOS 16+ (보편)	Android 8+ (API 26)

13. 퀴즈

Q1. Swift 6의 strict concurrency가 해결하는 주된 문제는?

A1. 데이터 레이스(data race)를 컴파일 타임에 검출. actor와 Sendable 프로토콜을 통해 동시성 안전한 코드를 강제한다. 런타임 충돌을 미연에 방지한다.

Q2. SwiftUI의 @State와 @Binding의 차이는?

A2. @State는 View 내부에서 소유하는 로컬 상태이고, @Binding은 부모로부터 전달받은 상태에 대한 양방향 참조이다. @Binding은 자식 View에서 부모의 상태를 수정할 수 있게 한다.

Q3. Jetpack Compose의 state hoisting이란?

A3. 상태(state)를 컴포저블 함수 내부가 아닌 호출자(parent)로 끌어올리는 패턴. 이를 통해 컴포저블을 stateless로 만들어 재사용성과 테스트 용이성을 높이고, 단방향 데이터 흐름(UDF)을 구현한다.

Q4. Kotlin Coroutines의 structured concurrency란?

A4. 부모 코루틴이 자식 코루틴의 생명주기를 관리하는 원칙. 부모가 취소되면 자식도 취소되고, 자식이 모두 완료되어야 부모도 완료된다. coroutineScope, viewModelScope 등이 이 원칙을 구현한다. 메모리 누수와 좀비 코루틴을 방지한다.

Q5. TCA(The Composable Architecture)의 핵심 개념 3가지는?

A5. 1) State - 기능의 상태를 표현하는 단일 구조체, 2) Action - 발생할 수 있는 모든 이벤트를 표현하는 enum, 3) Reducer - 현재 State와 Action을 받아 새 State와 Effect를 반환하는 순수 함수. 단방향 데이터 흐름과 테스트 가능성이 핵심.

14. 참고 자료

Apple - Swift.org Documentation: https://swift.org/documentation
Apple - SwiftUI Tutorials: https://developer.apple.com/tutorials/swiftui
Apple - Swift Concurrency: https://docs.swift.org/swift-book/documentation/the-swift-programming-language/concurrency
Apple - Human Interface Guidelines: https://developer.apple.com/design/human-interface-guidelines
Google - Jetpack Compose Documentation: https://developer.android.com/jetpack/compose
Google - Kotlin Documentation: https://kotlinlang.org/docs
Google - Android Architecture Guide: https://developer.android.com/topic/architecture
JetBrains - Kotlin Multiplatform: https://kotlinlang.org/docs/multiplatform.html
Point-Free - The Composable Architecture: https://github.com/pointfreeco/swift-composable-architecture
Swift Package Manager: https://swift.org/package-manager
Hilt - Dependency Injection for Android: https://dagger.dev/hilt
Material Design 3: https://m3.material.io
Google I/O 2024 Sessions: https://io.google
WWDC 2024 Sessions: https://developer.apple.com/wwdc24

15. 마치며

네이티브 개발은 2026년에도 여전히 모바일 앱의 황금 표준이다. Swift 6의 컴파일 타임 안전성과 Kotlin 2.0의 K2 컴파일러 성능 개선은 두 생태계를 더욱 강력하게 만들고 있다. SwiftUI와 Jetpack Compose는 선언형 UI의 패러다임을 완전히 정착시켰고, 비동기 처리, DI, 테스팅 전반에서 두 플랫폼이 서로의 모범 사례를 빠르게 흡수하고 있다.

크로스 플랫폼이 모든 요구사항을 충족할 수 없는 영역이 분명히 존재한다. 고성능 그래픽, 최신 OS 통합, 플랫폼 특화 UX가 필요한 앱이라면 네이티브가 정답이다. 두 플랫폼을 모두 익히는 것은 노력이 들지만, 그 보상은 그 어떤 크로스 플랫폼 솔루션보다 크다.