Son yıllarda mobil geliştirme dünyasında güçlü bir söylem var:
“Bir kere yaz, her yerde çalıştır.”
Flutter, React Native ve Kotlin Multiplatform gibi teknolojiler sayesinde bu artık mümkün. Hatta söylem bir adım daha ileri taşındı:
“Yakında native geliştirmeye gerek kalmayacak.”
Bu yazıda bu iddiaya daha teknik, daha gerçekçi ve sistem seviyesinde bir perspektiften yaklaşacağım.
Multiplatform Neden Bu Kadar Güçlü?
Multiplatform çözümler:
- Ortak business logic yazmayı sağlar
- Time-to-market’i ciddi şekilde düşürür
- Daha küçük ekiplerle ürün çıkarmayı mümkün kılar
- MVP ve startup süreçlerinde büyük avantaj sağlar
Bu noktada hiçbir tartışma yok:
Multiplatform güçlü bir araçtır.
Ama burada kritik bir yanlış anlama var.
Temel Gerçek: Multiplatform Native’in Yerine Geçmez
Multiplatform teknolojiler:
- Native API’leri kullanır
- Platformun render sistemine bağlıdır
- İşletim sisteminin sunduğu yeteneklerle çalışır
Yani:
Multiplatform bir alternatif değil, bir abstraction (soyutlama) katmanıdır.
Apple Her Yıl Ne Yapıyor?
iOS gibi platformlar statik değil. Sürekli gelişiyor.
Her yıl:
- Yeni UI yaklaşımları (örn: declarative UI sistemleri)
- Yeni gesture mekanizmaları
- Render pipeline optimizasyonları
- Yeni donanım erişimleri (GPU, kamera, ML)
ekleniyor.
Ve kritik nokta şu:
Bu yenilikler önce native’e gelir.
Multiplatform tarafı ise bu yenilikleri:
- Bekler
- Adapt eder
- Bazen hiç destekleyemez
“Tam Kontrol” Ne Demek?
Native geliştirme şu anlama gelir:
Doğrudan işletim sistemiyle çalışırsın.
Bu da şu avantajları getirir:
- Render sürecine doğrudan müdahale
- Gesture event’lerini ham haliyle yönetme
- Animation pipeline’ını kontrol etme
- Memory ve lifecycle üzerinde tam hakimiyet
Hiçbir aracı yoktur. Arada katman yoktur.
Pipeline Farkı (En Kritik Nokta)
Native: Senin kodun → iOS
Multiplatform: Senin kodun → Framework → Native → iOS
Bu ekstra katman:
- Gecikme (latency)
- Ek maliyet (overhead)
- Debug karmaşıklığı
getirir.
Gesture Sistemi Neden Kritik?
Mobil deneyimin kalbi: gesture.
Native’de:
- OS sana direkt touch event’lerini verir
- 60fps / 120fps pipeline ile senkron çalışır
- Multi-touch ve edge-case’ler doğrudan yönetilir
Multiplatform’da ise:
- Event önce framework’e gider
- Sonra çevrilir / taşınır
- Ek gecikme oluşur
Bu küçük farklar UX’te büyük fark yaratır.
Performans Gerçeği
Multiplatform uygulamalar genelde:
👉 “Yeterince iyi” performans verir.
Ama:
“En iyi” performansı vermez.
Neden?
- Bridge maliyeti (özellikle React Native)
- Ek abstraction layer
- Native optimizasyonların dolaylı kullanımı
En çok etkilenen alanlar:
- Scroll akıcılığı
- Complex animasyonlar
- Büyük listeler
- Gesture responsiveness
Direkt Sistem Erişimi Ne Demek?
Native geliştirici olarak:
OS’in sunduğu her şeye anında erişirsin.
Örnek:
- Yeni camera API → direkt kullanırsın
- Yeni animation sistemi → anında entegre edersin
- Yeni gesture → beklemeden kullanırsın
Multiplatform’da ise:
- Framework desteklemeli
- Wrapper yazılmalı
- Bazen hiç mümkün olmaz
Debug Gerçeği
Multiplatform’da bir bug çıktığında:
- Framework’te mi?
- Bridge’de mi?
- Native layer’da mı?
- Senin kodunda mı?
belirsizlik oluşur.
Bu da:
- Debug süresini uzatır
- Maintenance maliyetini artırır
Native’de ise:
Tek gerçeklik vardır.
UX Gerçeği
Kullanıcılar şunu bekler:
- iOS’ta iOS hissi
- Android’de Android hissi
Tek tip UI:
- Yapay hissedilir
- Platform davranışlarını kaçırır
- UX’i zayıflatır
Büyük Şirketler Ne Yapıyor?
Gerçek dünya yaklaşımı:
Hybrid model
- Business logic → shared
- UI → native
Çünkü:
- Performans kritik
- UX kritik
- Kontrol kritik
Abstraction’ın Doğası
Yazılım tarihinde her abstraction:
- Geliştirmeyi kolaylaştırır
- Yaygınlaşır
- Ama alt katmanı yok etmez
Örnekler:
- Assembly hâlâ var
- C hâlâ var
- Web, native’i bitirmedi
Multiplatform da aynı yolu izliyor.
Sonuç
Multiplatform:
Geliştirmeyi hızlandırır
Maliyeti düşürür
Harika bir araçtır
Ama:
Sınırları native belirler
Çünkü:
Başka bir teknolojiye bağımlı olan bir yapı, onu ortadan kaldıramaz.
Kapanış
Native geliştirme:
- Kontrol sağlar
- Performans sağlar
- Geleceğe doğrudan erişim sağlar
Multiplatform ise:
- Hız sağlar
- Kolaylık sağlar
- Soyutlama sağlar
Bu iki yaklaşım rakip değil.
Birlikte kullanıldığında en güçlü hale gelir.
Native Sadece Performans Değil, Zamanlama (Timing) Meselesidir
Mobil uygulamalarda performans sadece hız değildir.
Asıl kritik olan: doğru zamanda doğru frame’i üretmek
iOS tarafında:
- Input (touch) → RunLoop → Layout → Render → GPU → Display
tüm pipeline deterministik şekilde çalışır.
Native geliştirme:
Bu pipeline’ın bir parçası olmanı sağlar.
Multiplatform ise:
Bu pipeline’a sonradan dahil olur.
Bu fark:
- Frame drop
- Micro stutter
- Input lag
gibi kullanıcı tarafından hissedilen problemlere yol açar.
“%90 Yeter” Yanılgısı
Multiplatform çoğu zaman:
%90 senaryoda sorunsuz çalışır
Ama gerçek ürünler:
O %10 kritik senaryoda fark yaratır
Bu %10:
- Complex gesture + animation kombinasyonları
- High-frequency data rendering (örn: finans, chat)
- Low latency gerektiren etkileşimler
Büyük ürünlerin kalitesi burada belirlenir.
Escape Hatch Gerçeği
Multiplatform frameworklerin hepsinde bir kavram vardır:
Escape hatch (kaçış kapısı)
Yani:
“Burada native yazmak zorundasın”
Örnek:
- React Native → Native Modules
- Flutter → Platform Channels
- Kotlin Multiplatform → expect/actual
Bu şu anlama gelir:
En kritik noktada yine native’e dönersin.
Abstraction Leak (Soyutlama Sızdırır)
Bilgisayar bilimlerinde bilinen bir gerçek vardır:
“All abstractions leak”
Multiplatform’da bu şu şekilde görünür:
- Platforma özel bug’lar çıkar
- iOS ve Android davranışları ayrışır
- Tek kod yazma hayali kırılır
Sonuç:
Eninde sonunda platform detayını bilmek zorundasın.
Öğrenme Eğrisi Gerçeği
Multiplatform öğrenmek:
Native öğrenmeyi ortadan kaldırmaz
Aksine:
Üzerine ek yük getirir
Çünkü:
- Framework öğrenirsin
- Üstüne native öğrenmek zorunda kalırsın
- Debug için iki dünyayı da anlaman gerekir
Uzun Vadeli Risk
Multiplatform seçiminde genelde göz ardı edilen şey:
3-5 yıl sonrası
Riskler:
- Framework terk edilebilir
- Breaking change’ler gelebilir
- Community zayıflayabilir
Native tarafında ise:
Platform sahibi (Apple / Google) garantidir
Asıl Doğru Soru
Soru şu değil:
“Multiplatform native’i bitirir mi?”
Doğru soru:
“Hangi problemi çözmek için hangi aracı kullanmalıyım?”
Son Bir Gerçek
Multiplatform:
Ürün çıkarmayı kolaylaştırır
Native:
Ürünü mükemmelleştirir
En iyi ekipler:
Bu ikisini bilinçli şekilde birlikte kullanır
Gerçek Dünya Case Study: Scroll + Gesture Çöküşü
Birçok uygulamada karşılaşılan klasik ama kritik bir senaryo:
- Yatay scroll (carousel)
- İçinde dikey scroll (list)
- Üstüne swipe gesture (dismiss / action)
Bu yapı:
Native’de bile dikkat gerektirir
Multiplatform’da ise kırılgan hale gelir
Native (iOS)
Native tarafında:
- Gesture recognizer’lar override edilebilir
- Simultaneous gesture kontrolü yapılabilir
- Event propagation tamamen yönetilebilir
Örnek kontrol:
gestureRecognizer(_:shouldRecognizeSimultaneouslyWith:)require(toFail:)- Custom hitTest logic
Yani sistemin davranışını değiştirebilirsin
Multiplatform Tarafı
Aynı senaryoda:
- Gesture conflict oluşur
- Scroll “takılır” hissi verir
- Edge-case’lerde beklenmeyen davranış çıkar
Ve en kritik nokta:
Framework izin verdiği kadar çözebilirsin
Çoğu durumda çözüm:
Native’e inmek olur
Benchmark Gerçeği (Teorik Değil)
Basit bir liste düşün:
- 1000 item
- Image + text
- Smooth scroll beklentisi
Native (UITableView / UICollectionView)
- Cell reuse sistemi native
- Memory optimizasyonu built-in
- GPU pipeline ile uyumlu
Sonuç:
Stabil 60fps / 120fps
Multiplatform
React Native:
- JS thread + UI thread ayrımı
- Bridge communication cost
- Frame drop riski
Flutter:
- Kendi render engine’i (Skia)
- Native scroll davranışını taklit eder
Kotlin Multiplatform:
- UI native ise iyi
- Ama abstraction arttıkça kontrol azalır
Kritik Fark
Native:
OS ile birlikte çalışır
Multiplatform:
OS üzerinde çalışır
Bu küçük gibi görünen fark:
Büyük performans farkına dönüşür
Micro Stutter Nedir ve Neden Önemlidir?
Kullanıcı çoğu zaman şunu söylemez:
“Bu uygulama yavaş”
Ama şunu hisseder:
“Bir gariplik var”
Bu genelde:
- 16ms yerine 24ms frame üretmek
- Input ile render arasında gecikme
- Tutarsız frame pacing
olarak ortaya çıkar.
Buna denir:
Micro stutter
Native:
Frame timing’i daha stabil tutar
Multiplatform:
Bu stabiliteyi garanti edemez
Production Gerçeği: “Works on Demo” vs “Works at Scale”
Multiplatform demo’larda:
Her şey mükemmel görünür
Ama production’da:
- Gerçek veri gelir
- Edge-case’ler çıkar
- Performans baskısı artar
Ve şu fark ortaya çıkar:
“Çalışıyor” ile “iyi çalışıyor” aynı şey değildir
Sonuç: Nerede Hangisi?
Multiplatform Kullan:
- MVP
- Startup
- CRUD-heavy uygulamalar
- Hız kritikse
Native Kullan:
- High-performance UI
- Complex interaction
- Gesture-heavy deneyimler
- Uzun vadeli, büyük ürünler
Final Thought
En iyi mühendislik yaklaşımı:
“Tek doğru teknoloji” seçmek değil
“Doğru yerde doğru teknoloji” kullanmaktır
Çünkü:
Yazılımda kazananlar, araç seçimi doğru olanlardır — araç savunanlar değil.
Top comments (0)