iOS Geliştiricinin Android'e Geçişi: Yol Haritası

iOS geliştirici olarak yıllardır Swift ve SwiftUI ile çalışıyorsan, Android tarafına geçmek artık iki yıl önceki kadar yabancı bir dünyaya adım atmak gibi değil. Kotlin ve Swift ekosistemleri 2026'nın ortasında birbirine daha önce hiç olmadığı kadar yaklaştı; resmi Google eğitim müfredatı da iOS deneyimini önkoşul saymadan sıfırdan başlayan ücretsiz bir yol sunuyor. Bu yazıda, bir iOS geliştiricisi olarak Android öğrenirken hangi kavramların tanıdık geleceğini, hangilerinin gerçekten yeniden öğrenilmesi gerektiğini ve ilk 30 günü ve sonrasını nasıl planlayabileceğini adım adım anlatıyorum.

💡 Pro Tip: Android'e "sıfırdan" değil "Kotlin'in Swift'e en yakın olduğu noktadan" başla — nullability ve lambda söz dizimi ilk haftada seni rahatlatacak, asıl zorluk mimaride (UDF, ViewModel) çıkacak.

İçindekiler

• Geçişin kolaylaşmasının üç nedeni
• Swift'ten Kotlin'e kavram haritası (opsiyoneller, protokoller, coroutines)
• Söz dizimi karşılıkları tablosu
• Coroutines ile Swift concurrency yan yana
• Compose vs SwiftUI: zihinsel model farkı
• UDF: asıl zihinsel fark burada
• Form factors ve adaptif layout
• İlk 30 gün ve sonrası: somut çalışma planı
• İlk ay: Kotlin temelleri ve ilk Compose ekranı
• İkinci ay: mimari, ağ ve veri kalıcılığı
• Paylaşımlı çekirdek yolu: KMP ve Swift-Android
• İki resmi yol: hangi çekirdek paylaşılıyor
• expect/actual: platforma özel kodu ayırmak
• Portföyde ne göstermeli
• Sertifika gerçeği: kodlama değil, mağaza listeleme
• Portföyde öne çıkaracağın dört şey
• Kaçınılması gereken 5 alışkanlık
• SSS
• iOS geliştirici Android'e nasıl geçer?
• Swift bilen biri Kotlin'i ne kadar sürede öğrenir?
• Çift platform geliştirici olmak kariyer olarak mantıklı mı?
• Compose ile SwiftUI'yi aynı anda öğrenmek kafa karıştırır mı?
• KMP mi Swift-Android SDK mı, hangisiyle başlamalıyım?
• Güncelleme (Eylül 2026)
• Sonuç
• Kaynaklar

Geçişin kolaylaşmasının üç nedeni

2026 ortasına gelindiğinde iOS'tan Android'e geçişi eskisinden belirgin şekilde kolaylaştıran üç somut gelişme var.

Birincisi, Swift artık resmi olarak Android'de çalışıyor. 24 Mart 2026'da yayınlanan Swift 6.3, Android için ilk resmi Swift SDK sürümünü içeriyor. Swift.org'un duyurusunda şöyle deniyor: "Swift 6.3 includes the first official release of the Swift SDK for Android." Bu SDK ile Swift kodu, Swift Java ve Swift Java JNI Core üzerinden mevcut Kotlin/Java Android uygulamalarına entegre edilebiliyor. Yani bildiğin dil artık karşı tarafta da bir köprü kuruyor. Aynı sürümde gelen @c niteliği de dikkate değer: Swift.org'un ifadesiyle "Swift 6.3 introduces the @c attribute, which lets you expose Swift functions and enums to C code in your project."

İkincisi, Kotlin tarafı da bu köprüye karşılık veriyor. 3 Haziran 2026'da yayınlanan Kotlin 2.4.0, Kotlin/Native içinde Swift paketlerini bağımlılık olarak kullanma desteğini ve Swift export güncellemelerini getirdi. JetBrains'in duyurusunda "Kotlin/Native: Support for Swift packages as dependencies, updates on Swift export, and the CMS GC enabled by default" ifadesi geçiyor. İki dil ekosistemi artık birbirinin paket yöneticisini tanıyor. Aynı sürümde Kotlin/JVM tarafında Java 26 desteği de geldi ("Kotlin/JVM: Support for Java 26 and annotations in metadata enabled by default") — eğer daha önce sunucu tarafında Swift ile (Vapor gibi) çalıştıysan, Kotlin/JVM'in de benzer bir sunucu-tarafı ekosistemi olduğunu bilmek faydalı, çünkü Android dışında backend Kotlin koduna geçiş yapmak istersen aynı dil bilgisi orada da geçerli oluyor.

Üçüncüsü, Google'ın resmi eğitim programı iOS deneyimini önkoşul saymıyor. "Android Basics with Compose" kursunun önkoşulları yalnızca temel bilgisayar/matematik becerisi ve Android Studio çalıştırabilen bir bilgisayar — Swift veya iOS bilgisi istenmiyor. Bu, senin gibi deneyimli bir mobil geliştiricinin sıfırdan değil, "platforma özel detaylardan" başlayabileceği anlamına geliyor.

Swift'ten Kotlin'e kavram haritası (opsiyoneller, protokoller, coroutines)

Kotlin'i öğrenirken en çok zaman kazandıran şey, zihninde zaten var olan Swift kavramlarına karşılık arayabilmek. Google'ın resmi "Android Basics with Compose" kursunun 2. ünitesi (21 saat) tam olarak burada başlıyor: conditionals, nullability, classes, lambdas.

Söz dizimi karşılıkları tablosu

Coroutines ile Swift concurrency yan yana

Coroutines konusuna gelince, resmi kursun ayrı ve daha ileri bir ünitesi var: Unit 5 (9 saat), coroutines'i ağ çağrılarıyla (HTTP/REST, Retrofit) birlikte öğretiyor. Kotlin coroutines ile Swift'in async/await yapısı farklı hata yönetimi ve iptal kurallarına sahip; benzerliğe güvenip bunları atlama. Yapılandırılmış eşzamanlılık kuralları da iki tarafta birebir aynı değil, bu yüzden söz dizimini değil davranışı karşılaştır. Aşağıdaki iki örnek aynı işin iki dildeki karşılığını gösteriyor:

1// Kotlin — suspend fonksiyon + coroutine scope
2suspend fun fetchUser(id: String): User {
3    return withContext(Dispatchers.IO) {
4        api.getUser(id)
5    }
6}
7 
8// Çağrı: bir coroutine scope içinde
9viewModelScope.launch {
10    val user = fetchUser("42")
11    _uiState.value = UiState.Loaded(user)
12}

1// Swift — async fonksiyon + Task
2func fetchUser(id: String) async throws -> User {
3    try await api.getUser(id)
4}
5 
6// Çağrı: bir Task içinde
7Task {
8    let user = try await fetchUser(id: "42")
9    uiState = .loaded(user)
10}

suspend fun ile async func, viewModelScope.launch ile Task { } yapısal olarak benzer bir amaca hizmet ediyor: çağıran taraf iş parçacığını bloklamadan asenkron sonucu bekliyor. Ama hata yönetimi (try/catch vs Kotlin'in Result tipi veya exception), yapılandırılmış eşzamanlılık kuralları ve iptal (cancellation) mekanizmaları detayda farklılaşıyor — bunları ezberlemek yerine kodu yazarak öğrenmek daha sağlıklı.

Compose vs SwiftUI: zihinsel model farkı

Google, Jetpack Compose'u resmi kurs sayfasında şöyle tanımlıyor: "…Compose simplifies and accelerates UI development on Android with less code, powerful tools, and intuitive Kotlin APIs." SwiftUI'ye aşinaysan bu tanım sana tanıdık gelecek. "Jetpack Compose for Android developers" kursu, öğrenmeyi beş pathway'e ayırıyor: "Compose essentials", "Layouts, theming, and animation", "Architecture and state", "Accessibility, testing, and performance" ve "Form factors".

UDF: asıl zihinsel fark burada

Asıl zihinsel fark mimaride ortaya çıkıyor. Resmi müfredatın 4. ünitesi (28 saat), ViewModel, StateFlow ve UDF (unidirectional data flow) pattern'ini birlikte, ayrı bir blok olarak öğretiyor — Compose'un navigasyonuyla birlikte. SwiftUI'de de @State/@Observable ile benzer bir tek-yönlü veri akışı kurulabilir, ama Android tarafında UDF'nin resmi müfredatta bu kadar vurgulu, ayrı bir ünite olarak yer alması, Google'ın bunu "isteğe bağlı bir iyi pratik" değil, öğrenilmesi gereken temel bir mimari kural olarak gördüğünü gösteriyor.

1// Compose — state hoisting + UDF
2@Composable
3fun CounterScreen(viewModel: CounterViewModel = viewModel()) {
4    val uiState by viewModel.uiState.collectAsState()
5    Column {
6        Text("Sayı: ${uiState.count}")
7        Button(onClick = { viewModel.increment() }) {
8            Text("Artır")
9        }
10    }
11}
12 
13class CounterViewModel : ViewModel() {
14    private val _uiState = MutableStateFlow(CounterState())
15    val uiState: StateFlow<CounterState> = _uiState.asStateFlow()
16 
17    fun increment() {
18        _uiState.update { it.copy(count = it.count + 1) }
19    }
20}

Buradaki ders şu: composable fonksiyon kendi state'ini tutmuyor, ViewModel'den okuyor ve olayı (increment()) yukarı iletiyor — tam da UDF'nin tanımı. SwiftUI'de @Observable class + Button(action:) ile aynı deseni kurmak mümkün, ama Compose müfredatı bunu baştan zorunlu kılıyor.

Form factors ve adaptif layout

Beşinci pathway'in adı da ("Form factors") dikkat çekiyor: "Jetpack Compose for Android developers" kursu bunu ayrı bir öğrenme bloğu olarak listeliyor. Ayrıca "Android Basics with Compose" kursu, kendi tanımında "farklı ekran boyutları için adaptif layout'ları" kapsadığını belirtiyor. iOS tarafında tek bir SwiftUI view'ının iPhone ve iPad arasında adaptif davranmasına alışkınsın; Android tarafında da bu ihtiyacın ayrı bir müfredat başlığı olarak ele alındığını görmek, telefon/tablet/katlanabilir cihaz çeşitliliğinin Google için de öncelikli bir konu olduğunu gösteriyor.

İlk 30 gün ve sonrası: somut çalışma planı

Planı uydurmak yerine, doğrudan Google'ın resmi "Android Basics with Compose" kursunun saat dökümüne dayandırıyorum. Kurs 8 üniteye ve toplam yaklaşık 100 saate ayrılmış; günde ~1,5-2 saat ayırırsan ilk 30 günde ilk üç üniteyi (46 saat) bitirirsin.

İlk ay: Kotlin temelleri ve ilk Compose ekranı

Bu üç ünite bittiğinde Swift'ten getirdiğin nullability ve closure sezgisi Kotlin söz dizimine oturmuş, ilk Compose ekranlarını yazabiliyor olursun. Sonraki ay için Unit 4 (mimari: ViewModel/StateFlow/UDF, 28 sa), Unit 5 (coroutines + ağ, 9 sa) ve Unit 6 (Room + DataStore, 10 sa) doğal sırada devam eder — toplam kurs boyunca iOS/Swift deneyimi hiçbir noktada önkoşul olarak istenmiyor.

İkinci ay: mimari, ağ ve veri kalıcılığı

İkinci ay için de aynı saat dökümünden bir plan çıkarabilirsin:

İki aylık bu plan, resmi kursun tüm 100 saatinin büyük kısmını kapsıyor; Swift tarafında SwiftData/CoreData ve UserDefaults ile zaten aşina olduğun kavramların Android karşılıklarını (Room, DataStore) bu son haftalarda göreceksin — burada framework'ün ismi değişiyor, ama "yerel veritabanı + basit anahtar-değer deposu" ayrımı aynı kalıyor.

Paylaşımlı çekirdek yolu: KMP ve Swift-Android

Burada iki ayrı ve birbirini tamamlayan resmi yol var; ikisini karıştırmamak önemli.

İki resmi yol: hangi çekirdek paylaşılıyor

Yol A — Kotlin Multiplatform (KMP): Google'ın "Basics of Kotlin Multiplatform" pathway'i, paylaşılan Kotlin çekirdeğini iOS'a taşımanın iki resmi yolunu tanımlıyor: shared modülü doğrudan Xcode projesine entegre etmek, veya "shared modülü diğer herhangi bir Swift kütüphanesi gibi bağımsız bir Swift Package olarak yayınlamak" (resmi ifadeyle: "…release your shared KMP module as a standalone Swift Package for use by an iOS app, similar to any other Swift library"). Pathway ayrıca Room veritabanının KMP'ye taşınmasını, kod tekrarını azaltan somut bir örnek olarak kapsıyor.

Yol B — Swift'i Android'e taşımak: Swift 6.3'ün resmi Android SDK'sı, tam tersi yönde çalışıyor — mevcut bir Kotlin/Java Android uygulamasına Swift kodu entegre etmeni sağlıyor. Kotlin 2.4.0'ın Swift paketi bağımlılığı desteği de bu köprüyü Kotlin tarafından güçlendiriyor.

Kısacası: KMP = paylaşılan Kotlin çekirdeği + iOS istemci; Swift-Android SDK = paylaşılan Swift çekirdeği + Android istemci. Hangisini seçeceğin, ekibinin hangi dilde daha derin uzmanlığı olduğuna bağlı — ikisi de 20 Haziran 2026 itibarıyla resmi olarak yayınlanmış durumda (Swift SDK for Android, Swift 6.3 ile nightly önizlemelerden resmi sürüme geçti).

expect/actual: platforma özel kodu ayırmak

KMP'de platforma özel kodu ayırmak için kullanılan expect/actual deseni, Swift geliştiricisine protokol + platform-özel implementasyon mantığını hatırlatır:

1// commonMain/kotlin/PlatformInfo.kt — ortak arayüz
2expect class PlatformInfo() {
3    val osName: String
4}

1// androidMain/kotlin/PlatformInfo.kt — Android implementasyonu
2actual class PlatformInfo actual constructor() {
3    actual val osName: String = "Android"
4}

1// iosMain/kotlin/PlatformInfo.kt — iOS implementasyonu
2actual class PlatformInfo actual constructor() {
3    actual val osName: String = "iOS"
4}

Portföyde ne göstermeli

Sertifika gerçeği: kodlama değil, mağaza listeleme

Burada net bir ayrım gerekiyor: Google'ın kodlama yeterliliğini belgeleyen bir "Android geliştirici tamamlama sertifikası" programı yok. Yürüttüğü resmi sertifika programı Google Play Store Listing Certificate — bu bir mağaza listeleme/pazarlama sertifikası, kodlama yeterliliği belgesi değil.

Portföyde öne çıkaracağın dört şey

Portföyünü kurarken ben şu dört şeye öncelik vermeni öneririm:

• Tamamladığın pathway'leri işaretle. Compose'un 5 pathway'i ("Compose essentials", "Layouts, theming, and animation", "Architecture and state", "Accessibility, testing, and performance", "Form factors") ve KMP pathway'i, ilerlemeni somut şekilde gösterir.
• Aynı uygulamayı iki platformda göster. KMP ile paylaşılan bir Room/veri katmanı üzerine kurulmuş, hem Android hem iOS istemcisi olan küçük bir proje, "Yol A"yı gerçekten anladığını kanıtlar.
• UDF'yi bilinçli uyguladığını göster. ViewModel + StateFlow + tek yönlü veri akışıyla yazılmış bir ekran, mülakatta "neden bu şekilde" sorusuna resmi müfredata dayanan bir cevap vermeni sağlar.
• Play Console'da gerçek bir yayın sürecinden geçtiğini belirt. Google Play Store Listing Certificate'i tamamlamak, mağaza listeleme tarafında da fikrin olduğunu gösterir — App Store Connect deneyimine paralel bir yetkinlik. Play Console'a ilk kez gireceğin gün, App Store Connect'te alışkın olduğun "listele → test et → yayınla" akışının bir benzerini arayarak yön bulabilirsin.

Kaçınılması gereken 5 alışkanlık

Aşağıdaki maddeler, Google'ın resmi müfredatındaki vurgu dağılımından çıkardığım pratik gözlemler — iOS'tan gelen bir geliştiricinin en sık takıldığı noktalar.

1. UDF'yi atlayıp state'i her yerden mutasyona açmak. Resmi müfredatın ViewModel/StateFlow/UDF'yi ayrı, 28 saatlik bir ünite olarak ele alması, bunun "opsiyonel bir iyi pratik" değil temel bir kural sayıldığının işareti.
2. Erişilebilirliği en sona bırakmak. Compose kursunda Accessibility, Testing ve Performance aynı pathway'de birlikte, ayrı bir blok olarak veriliyor — sona atılacak bir "nice to have" değil.
3. Coroutines'i Swift concurrency ile birebir aynı sanmak. suspend/Task benzerliğine güvenip hata yönetimi ve iptal detaylarını atlamak hatalara yol açar.
4. KMP ile Swift-Android SDK'yı karıştırmak. Biri paylaşılan Kotlin çekirdeği, diğeri paylaşılan Swift çekirdeği — hangi yönde paylaşım yaptığını netleştirmeden mimari karar vermek, ileride büyük bir refactor'a mal olur.
5. Room/DataStore'u en sona bırakmak. Unit 6, veri kalıcılığını (Room) ve anahtar-değer depolamayı (DataStore) ayrı bir ünite yapıyor; SwiftData/UserDefaults'a aşina bir geliştirici için bu genelde hızlı geçilebilecek bir alan olsa da müfredat bunu ayrı tutuyor, yani atlanacak kadar önemsiz değil.

SSS

iOS geliştirici Android'e nasıl geçer?

En hızlı yol, Google'ın resmi ücretsiz müfredatını sırayla takip etmek: önce "Android Basics with Compose" ile Kotlin ve Compose temellerini, ardından "Jetpack Compose for Android developers" ile mimariyi, isteğe bağlı olarak da "Basics of Kotlin Multiplatform" ile paylaşılan çekirdek yaklaşımını öğrenmek. Bu kursların hiçbiri iOS veya Swift deneyimini önkoşul saymıyor, yani doğrudan başlayabilirsin.

Swift bilen biri Kotlin'i ne kadar sürede öğrenir?

Kesin bir resmi süre yok, ama resmi kursun kendi saat dökümü bir referans veriyor: "Android Basics with Compose" toplam ~100 saatlik, 8 üniteli bir kurs. Swift'ten gelen nullability ve lambda sezgisi sayesinde ilk iki üniteyi (Unit 1 + Unit 2, 31 saat) genelde daha hızlı geçersin; asıl zaman mimariyi (UDF, ViewModel, 28 saat) içselleştirmeye gider.

Çift platform geliştirici olmak kariyer olarak mantıklı mı?

Kariyer kararı kişisel bağlama bağlı; teknik zemin açısından somut olan şu: Swift 6.3'ün resmi Android SDK'sı ve Kotlin 2.4.0'ın Swift paketi desteği, iki ekosistemin birbirine teknik olarak yaklaştığını gösteriyor; bu da çift platform yetkinliğinin araç desteği açısından eskisinden daha az sürtünmeli hale geldiği anlamına geliyor.

Compose ile SwiftUI'yi aynı anda öğrenmek kafa karıştırır mı?

İki framework'ün de "az kod, deklaratif UI" felsefesini paylaştığını bilmek karışıklığı azaltır. Zorluk framework'lerin kendisinde değil, Android'in UDF vurgusu gibi platforma özgü mimari kurallarda çıkıyor.

KMP mi Swift-Android SDK mı, hangisiyle başlamalıyım?

Ekibinin çekirdek dil uzmanlığına bak: Kotlin'de daha güçlüyseniz KMP ile paylaşılan çekirdeği iOS'a taşımak, Swift'te daha güçlüyseniz Swift 6.3'ün Android SDK'sıyla tersini yapmak daha az sürtünme yaratır. İkisi de 20 Haziran 2026 itibarıyla resmi olarak destekleniyor.

Güncelleme (Eylül 2026)

Bu yazının gövdesi 20 Haziran 2026 itibarıyla geçerli araç ve sürümlerle yazıldı. O tarihten bu yana öğrenme yolunu etkileyebilecek birkaç somut gelişme oldu:

• Swift 6.4 (15 Eylül 2026): Swift/Java interop genişletildi ve Swift Build, SwiftPM içinde varsayılan derleme sistemi oldu — Swift-Android köprüsü yayına girdiğinden bu yana pekişmeye devam ediyor. Kaynak: swift.org/blog/swift-6.4-released/
• AGP 9.2 + R8 (27 Temmuz 2026): Android Gradle Plugin güncellemesiyle birlikte Kotlin Coroutines'in Android üzerindeki performansı 2 kat hızlandı — resmi Android Developers blogunda duyuruldu. Coroutines'i yeni öğrenen biri için derleme/performans tarafında ek bir sürtünme yok, aksine daha hızlı bir zemin var.
• Kotlin 2.5.0-Beta1 (23 Eylül 2026): Companion extensions ve companion blocks gibi yeni dil özellikleri beta aşamasında; bu yazıdaki Kotlin 2.4.0 temelli örnekler hâlâ geçerli, 2.5 kararlı sürüm çıktığında ek bir "ne değişti" notuna ihtiyaç olabilir.
• AndroidX Security State Libraries (17 Eylül 2026): Yeni güvenlik durumu kütüphaneleri duyuruldu — öğrenme yol haritasının ötesinde, ileri seviye bir konu olarak not düşülmeye değer.

Bu maddelerin hiçbiri yazının gövdesindeki temel yol haritasını (Kotlin temelleri → Compose → mimari → KMP) geçersiz kılmıyor; yalnızca araç setinin sürekli geliştiğini gösteriyor.

Sonuç

Swift 6.3'ün resmi Android SDK'sı ve Kotlin 2.4.0'ın Swift paketi desteği, 2026 ortasında iki ekosistemi birbirine önceki yıllara göre belirgin şekilde yaklaştırdı. Ama asıl fark yapan, Google'ın "Android Basics with Compose" ve "Jetpack Compose for Android developers" kurslarının iOS deneyimini önkoşul saymadan, net bir saat dökümüyle ilerleyen ücretsiz bir müfredat sunması. Swift'ten getirdiğin nullability ve closure sezgisiyle Kotlin'e hızlı ısınabilir, asıl enerjini UDF ve mimari kurallara ayırabilirsin.

Devam etmek istersen 2026'da öğrenilmesi gereken 10 teknoloji yazısıyla daha geniş bir bağlam kurabilir, Kotlin Multiplatform 1.1 production vaka analizi ile paylaşımlı çekirdek yaklaşımını gerçek bir projede görebilir, Compose Multiplatform ile Android-iOS production yazısıyla bir adım ileri gidebilirsin. Kotlin derleyicisinin yeni özelliklerini merak ediyorsan Kotlin 2.1 K2 compiler ve context parameters yazısına, Compose'da performans konusuna eğilmek istersen Jetpack Compose 1.7 performance ve strong skipping yazısına bakabilirsin. Mülakat sürecine hazırlanmak istersen iOS interview preparation yazısındaki bazı prensipler Android tarafı için de geçerli.

Kaynaklar

• Swift 6.3 Released — Android için ilk resmi Swift SDK duyurusu.
• Swift 6.4 Released — Swift/Java interop genişlemesi ve Swift Build varsayılanı.
• Kotlin 2.4.0 — What's New — Kotlin/Native Swift paketi desteği ve context parameters.
• Kotlin 2.4.0 GitHub Release — yayın tarihinin birincil doğrulaması.
• Android Courses — Google resmi kurs kataloğu — tüm pathway ve kursların listesi.
• Android Basics with Compose — ünite dökümü ve saat planı.
• Basics of Kotlin Multiplatform pathway — KMP'nin iki resmi iOS entegrasyon yolu.
• Jetpack Compose for Android developers — 5 pathway'lik Compose müfredatı.
• Google Play Store Listing Certificate — resmi mağaza listeleme sertifikası.
• How R8 made Kotlin Coroutines on Android 2x faster — AGP 9.2 + R8 ile coroutines performansı duyurusu.
• Introducing the AndroidX Security State Libraries — AndroidX Security State kütüphanelerinin duyurusu.