Clean Kotlin Multiplatform Code: Best Practices for Maintainable Apps

Why Clean Code Matters in KMP

Poorly structured Kotlin Multiplatform projects often face:

• 80% longer debugging sessions due to tangled logic
• 3x slower feature development from unclear architecture
• 50% higher maintenance costs across Android/iOS/web

1. Maximizing Code Reuse

1.1 Strategic <a href="https://androidboss.info/kotlin-multiplatform-mastering-platform-specific-code-with-expect-actual/" data-type="post" data-id="415">expect/actual</a> Usage

Shared Interface (commonMain)

expect interface BiometricAuthenticator {  
    fun authenticate(): Boolean  
}  

Platform Implementations

// Android  
actual class AndroidBiometricAuth : BiometricAuthenticator {  
    actual override fun authenticate() =  
        BiometricPrompt(...).authenticate()  
}  

// iOS  
actual class IosBiometricAuth : BiometricAuthenticator {  
    actual override fun authenticate() =  
        LAContext().canEvaluatePolicy(...)  
}  

Best Practices:

• Keep platform-specific code under */src/androidMain and */src/iosMain
• Use interfaces for shared contracts

2. Project Structure for Scalability

2.1 Modular Architecture

shared/  
├── core/              # Networking, database, utils  
│   ├── network/  
│   └── database/  
├── features/          # Feature modules  
│   ├── auth/  
│   └── profile/  
└── app/               # App entry points  

Key Benefits:

• Independent team workflows
• Reduced merge conflicts
• Faster incremental builds

3. Concurrency with Coroutines

3.1 Structured Concurrency Pattern

class UserViewModel : ViewModel() {  
    private val _users = MutableStateFlow<List<User>>(emptyList())  
    val users: StateFlow<List<User>> = _users  

    fun loadUsers() {  
        viewModelScope.launch {  
            _users.value = try {  
                userRepository.fetchUsers() // Suspend function  
            } catch (e: Exception) {  
                handleError(e)  
                emptyList()  
            }  
        }  
    }  
}  

3.2 Dispatcher Guidelines

4. Code Quality Enforcement

4.1 Static Analysis Setup

build.gradle.kts Configuration:

plugins {  
    id("org.jlleitschuh.gradle.ktlint") version "11.6.1"  
}  

ktlint {  
    disabledRules.set(setOf("import-ordering"))  
    filter {  
        exclude("**/generated/**")  
    }  
}  

Checks to Enable:

• Cyclomatic complexity
• Nested class depth
• Code duplication

4.2 Documentation Standards

KDoc Template:

/**  
 * Fetches user profile from backend  
 *  
 * @param userId UUID generated during registration  
 * @return [User] object with profile data  
 * @throws AuthException If JWT token is invalid  
 */  
suspend fun getProfile(userId: String): User  

5. Performance Optimization

5.1 Memory Management

Common Leak Sources:

• Unclosed database connections
• Coroutine scope mismanagement
• Platform-specific resource handles

Prevention:

DisposableEffect(Unit) {  
    val sensor = SensorManager()  
    sensor.start()  
    onDispose { sensor.stop() } // Critical for iOS/Android  
}  

5.2 Platform-Specific Profiling

6. Error Handling Strategy

6.1 Unified Error Model

sealed class AppError {  
    data class Network(val code: Int) : AppError()  
    data class Database(val message: String) : AppError()  
    object AuthExpired : AppError()  
}  

fun handleError(error: AppError) {  
    when (error) {  
        is AppError.Network -> showSnackbar("Check internet connection")  
        is AppError.Database -> logCrashlytics(error.message)  
        AppError.AuthExpired -> navigateToLogin()  
    }  
}  

6.2 Logging Implementation

Multiplatform Setup:

expect <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Logger</span> </span>{      fun debug(message: String)      fun error(throwable: Throwable)  }  // Android actual  actual <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">AndroidLogger : Logger</span> </span>{      actual override fun debug(message: String) = Log.d(<span class="hljs-string">"App"</span>, message)  }  // iOS actual  actual <span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">IosLogger : Logger</span> </span>{      actual override fun debug(message: String) = NSLog(<span class="hljs-string">"<span class="hljs-variable">%@</span>"</span>, message)  }  

Key Takeaways

1. Architect Modularly: Isolate features for team scalability
2. Coroutine Discipline: Use structured concurrency religiously
3. Static Analysis: Enforce code quality via ktlint/Detekt
4. Unified Errors: Standardize cross-platform error handling
5. Profile Early: Identify platform-specific bottlenecks

Internal Links

• A Comprehensive Guide to Cross-Platform Development
• How to Switch Ruby Versions on Mac (M1, M2, M3, M4 Guide)
• Mastering Lifecycle & Performance in Compose Multiplatform | Cross-Platform Optimization Guide

External Links

• Kotlin Coding Conventions
• Ktor Documentation