Belki de uygulamayı indirip bu problemi yaşayan birçok kişi bu yüzden aboneliğini iptal etti. Forumları inceleyip kullanıcı şikayetlerini okudum. Birçok kişi farklı farklı problemlerden şikayet etmiş ama aralarında bir tane bile böyle bir sorun yaşayan göremedim. O zaman bu benim cihazımla ilgiliydi.

Aboneliği hemen iptal edip hayata devam etmeyi kendime yakıştıramadım ve araştırmaya başladım. Bu süreçte araştırdığım, uygulamanın arka planda çalışamamasına sebep olacak sorunları da burada anlatmak istedim.

1. Versiyon

7 yıl boyunca Android 8.1 kullanmış biri olarak telefonum uygulamaları yavaş yavaş desteklememeye başlamıştı. Hatta yeni telefon almamın en büyük sebepleri arasındaydı. Artık bu problemi yaşamamam gerekiyor çünkü Android 14 versiyonu oldukça yeni sayılabilecek bir versiyon olup, eğer 14’ü bile desteklemiyorsa %55–60’lık bir kullanıcı kitlesini çöpe atmış olacaktı.

Yine de Play Store’daki en güncel versiyon olup olmadığını kontrol ettim.

2. İzinler

Başlangıçta benden bildirimler için izin istemedi. Ben yine de bildirim izinlerini açtım. Yine olmayınca bildirim ayarlarından uygulamanın zorunlu, zorunsuz tüm bildirimlerine izin verdim. Ama maalesef değişen bir şey yok.

3. Artık Beni Aşıyor?

Konunun benim tahminlerimin ve yapabileceklerimin üstünde olabileceğini düşündüm. Belki benim cihazımın tam olarak desteklemediği bir şey vardı. Storytel destek ile iletişime geçtim. Başta izinler ve versiyon kontrolünü yapmamı istediler. Bunları zaten yapmıştım. Beni geçiştirmeden çözüm bulmak için iletişimde kaldılar. Son yapmamı istedikleri ve işe yarayan kısım: pil optimizasyonu.

4. Hata Sebebi ve Çözüm

Android sürümleri ilerledikçe sistemin arka plan uygulamalarına karşı giderek daha agresif davrandığını fark ediyoruz. Özellikle medya oynatıcı gibi sürekli çalışan uygulamalarda bu oldukça net.

Aslında problemin kaynağı, pil optimizasyonunu kapattıktan sonra uygulamanın sorunsuz şekilde arka planda çalışmaya başlamasıyla ortaya çıktı. Sorun ne uygulamanın versiyonuydu ne de izinlerdi. Sorun doğrudan Android’in kendisiydi.

Android, yıllar içinde arka planda çalışan uygulamalara karşı giderek daha katı kurallar koymaya başladı. Bu durum ilk olarak Android 6.0 Marshmallow ile gelen Doze Mode ile ortaya çıktı. Sistem, cihaz kullanılmadığında uygulamaların işlemci ve internet erişimini kısıtlayarak pil tasarrufu yapmaya başladı.

Android 8.0 Oreo ile birlikte bu yaklaşım biraz daha ileri taşındı. Artık arka planda çalışan servisler belirli bir süre sonra sistem tarafından otomatik olarak durduruluyor. Yani bir uygulama “ben arka planda çalışmaya devam edeceğim” demediği sürece, Android birkaç dakika içinde onu kapatabiliyor.

Android 9 Pie ve sonrasında daha da agresif hale geldi. Sistem, uygulamaları kullanım sıklığına göre sınıflandırıp az kullanılanların arka plan aktivitelerini ciddi şekilde kısıtlamaya başladı.

Benim yaşadığım senaryoda da tam olarak bu oldu. Uygulama arka planda çalışıyor gibi görünüyordu, bildirim çubuğunda media player duruyordu… ama birkaç dakika sonra sistem uygulamayı “gereksiz” olarak değerlendirip kapatıyordu. Bildirimin kaybolmasının sebebi de buydu.

Pil optimizasyonunu kapattığımda ise Android artık uygulamaya müdahale etmemeye başladı ve her şey normal şekilde çalıştı.

Android sürümleri yükseldikçe sistem daha akıllı hale geliyor ama aynı zamanda daha agresif davranıyor. Ve bunun arkasındaki temel motivasyon her zaman aynı: pil ömrünü uzatmak.

Ne Anlatmak İstiyorum

İster bir abonelik olsun, ister bir hayalimiz, ister aklımızdan geçen bir düşünce; “çalışmıyor, olmuyor, uygulama bozuk, ben yapamam” gibi önyargılar bizi hayatın güzelliklerinden uzaklaştırıyor. Eğer bir şeyi yapmak istiyorsak bu bahanelerin arkasına kaçmayı bırakmamız gerek. Ne zaman ki daha çözüm odaklı oluruz, işte o zaman yaşıyoruz demektir.

Son olarak bana hep çözüm odaklı yaklaşan Storytel Türkiye ekibine teşekkür ederim.

Jetpack Compose, Android geliştiricileri için modern, deklaratif bir UI oluşturma aracıdır. Doğru kullanıldığında esneklik ve hız kazandırır, ancak yanlış kullanımı ciddi performans sorunlarına neden olabilir. Kullanıcı arayüzünün beklenenden daha yavaş çalışması, uygulamanın donması veya cihazın aşırı kaynak tüketmesi gibi problemler, performans optimizasyonlarının göz ardı edilmesiyle ortaya çıkar.

Örneğin, gereksiz recomposition işlemleri CPU kullanımını artırırken, yanlış state yönetimi UI’nin yavaş ve düzensiz çalışmasına yol açabilir. Benzer şekilde, büyük veri kümelerini işlemek için yanlış listeleme bileşenlerinin kullanılması uygulamanın akıcılığını bozabilir. Bu yazıda, Jetpack Compose’un performansını optimize etmek için izlenmesi gereken en iyi uygulamaları detaylandıracağız.

Jetpack Compose ve Recomposition Yönetimi

Jetpack Compose, kullanıcı arayüzünü güncellemek için “Recomposition” adı verilen bir mekanizma kullanır. Bir state değiştiğinde, ilgili bileşenler yeniden oluşturulur. Ancak, gereksiz recomposition işlemleri performans kayıplarına yol açabilir.

Örneğin, bir state değişkeni remember kullanılmadan oluşturulursa, her recomposition sırasında tekrar oluşturulur ve bu gereksiz hesaplama yükü getirir. Bunun önüne geçmek için, değişmeyen veya sık değişmeyecek verileri remember ile saklamak gerekir. Benzer şekilde, hesaplamaların gereksiz yere çalışmasını önlemek için derivedStateOf kullanarak sadece ilgili veriler değiştiğinde hesaplama yapmak en doğru yaklaşımdır.

Yanlış kullanım:

var count = mutableStateOf(0) // Her recomposition'da sıfırlanır

Doğrusu:

val count = remember { mutableStateOf(0) } // Değer korunur

Yaygın bir hata da, UI bileşenlerinde gereksiz lambda ifadeleri kullanmaktır. Lambda fonksiyonları her çağrıldığında yeniden oluşturulabilir ve bu da gereksiz recomposition’lara sebep olabilir. Bunu önlemek için fonksiyon referansları kullanılmalıdır.

Yanlış kullanım:

Button(onClick = { performAction() }) { Text("Tıkla") } // Her çağrıda yeni lambda oluşturulur

Doğrusu:

val updatedAction by rememberUpdatedState(performAction)
Button(onClick = { updatedAction() }) { Text("Tıkla") }
// Daha verimli

State Yönetimi ve Performans

Jetpack Compose’da state yönetimi, performans üzerinde doğrudan etkili olan kritik bir konudur. Yanlış state kullanımı, gereksiz recomposition’lara sebep olabilir ve kullanıcı deneyimini olumsuz yönde etkileyebilir.

Örneğin, global olarak tanımlanmış state değişkenleri gereksiz recomposition’lara yol açabilir. Bunun yerine, yalnızca belirli bileşenler için gerekli olan state, mümkün olan en düşük kapsamda tutulmalıdır. State değişiklikleri gereksiz bileşenleri etkilememeli, yalnızca doğrudan bağlantılı olan bileşenleri güncellemelidir.

Yanlış kullanım:

var username by mutableStateOf("") // Tüm bileşenleri etkileyebilir

Doğrusu:

val username = remember { mutableStateOf("") } // Sadece gerekli bileşen etkilenir

Ayrıca, asenkron işlemler sırasında UI’nin donmasını önlemek için produceState ve LaunchedEffect gibi API’ler kullanılmalıdır. Örneğin, bir ağ isteği veya veritabanı sorgusu tamamlanana kadar UI’nin bloklanmasını önlemek için bu yaklaşımlar tercih edilmelidir.

Lazy Lists Optimizasyonu

Jetpack Compose, büyük veri kümeleri ile çalışırken LazyColumn ve LazyRow gibi bileşenleri kullanarak performans optimizasyonu sağlar. Ancak, yanlış kullanım performansı olumsuz etkileyebilir.

Yanlış yapılanlardan biri, LazyColumn yerine Column gibi statik bileşenlerin kullanılmasıdır. Bu durumda, Compose tüm öğeleri baştan oluşturur ve bellekte gereksiz yük oluşturur. Doğru yaklaşım, yalnızca görünen öğelerin oluşturulmasını sağlayan LazyColumn gibi bileşenleri kullanmaktır.

Yanlış kullanım:

Column {
items.forEach { item ->
Text(text = item.name)
}
}

Doğrusu:

LazyColumn {
items(items, key = { it.id }) { item ->
Text(text = item.name)
    }
}

Bir başka hata ise, LazyColumn içindeki öğelerin key() özelliğinin belirtilmemesidir. Key tanımlanmadığında, liste kaydırıldığında bile Compose hangi öğelerin değişmediğini anlamaz ve gereksiz yeniden çizim işlemleri gerçekleşir.

Profiling ve Performans Ölçümü

Jetpack Compose’da performans sorunlarını tespit etmek ve gidermek için Android’in sunduğu analiz araçları kullanılmalıdır:

• Layout Inspector: UI bileşenlerinin nasıl yeniden oluşturulduğunu ve gereksiz recomposition’ları görselleştirmek için kullanılır.
• Android Profiler: CPU, bellek ve UI performans analizlerini yapmak için kullanılır. Özellikle ağır çalışan işlemleri tespit etmek için faydalıdır.
• Compose Compiler Metrics: Compose bileşenlerinin recomposition ve yeniden çizim analizlerini yapmak için kullanılır. Derleme aşamasında, gereksiz recomposition’ları ve verimsiz kodları tespit etmeye yardımcı olur.
• JankStats API: UI performansını etkileyen gecikmeleri (jank) ölçmek için kullanılır. Kullanıcı deneyimini etkileyen kare düşüşlerini ve yavaşlıkları analiz etmeye yardımcı olur.

Bazı geliştiriciler, performans ölçümleri için manuel zaman damgası alarak işlem süresi hesaplamaya çalışır. Ancak, bu yöntem güvenilir değildir ve yanıltıcı sonuçlar verebilir. Bunun yerine, Trace API gibi yerleşik araçların kullanılması önerilir.

Diğer Performans İyileştirmeleri

Jetpack Compose uygulamalarında performansı artırmak için şu teknikler de göz önünde bulundurulmalıdır:

• Karmaşık UI bileşenlerini ayrı Composable fonksiyonlara bölmek: Büyük bileşenler, bağımsız parçalara ayrılmalıdır. Böylece gereksiz recomposition’lar en aza indirilebilir.
• Asenkron işlemleri optimize etmek: Ağ istekleri veya veritabanı işlemleri gibi işlemler LaunchedEffect, produceState veya rememberCoroutineScope ile yürütülmelidir.
• Görsel performansı artırmak: Ağır UI işlemleri için Canvas veya DrawScope gibi Compose’un optimize edilmiş çizim API’leri kullanılabilir.

Sonuç

Jetpack Compose, modern Android UI geliştirmeyi hızlandıran güçlü bir araçtır. Ancak, yanlış kullanıldığında performans sorunlarına yol açabilir. Gereksiz recomposition’ların önlenmesi, state yönetiminin optimize edilmesi, Lazy list kullanımında dikkat edilmesi gerekenler ve performans analiz araçlarının etkin kullanımı ile daha hızlı ve akıcı bir kullanıcı deneyimi sağlanabilir.

Bu yazıda ele aldığımız en iyi uygulamalar, Jetpack Compose projelerinizde performansı artırmanıza yardımcı olacaktır. UI bileşenlerini nasıl yönettiğinize dikkat ederek, hem kullanıcılarınız hem de cihaz kaynakları için daha verimli uygulamalar geliştirebilirsiniz.

bir dahaki yazıda yine buluışmak dileğiyle…

Kaynakça:

Jetpack Compose Performance | Android Developers

“Mükemmellik bir eylem değil, bir alışkanlıktır.” — Aristoteles

Takvimler 2025’i gösteriyor. Yeni bir yıl, yepyeni bir başlangıç. Hep olduğu gibi, bu yıl da hayatımızda değişiklikler yapmayı, kendimizi geliştirmeyi ve zamanımızı daha verimli kullanmayı hedefledik. Ama maalesef çoğumuzun bu kararları birkaç hafta içinde unuttuk. Peki, neden? 🤔

Ne demiş Aristoteles; değişim alışkanlıklarda gizli. Eylemi alışkanlık haline getirsek, artık ona odaklanmak zor olmuyor. Mesela sabahları dişlerinizi fırçalarken “Dişlerimi fırçalamalı mıyım?” diye sorgulamayız. Aynı şekilde, zamanı iyi yönetmek alışkanlık haline geldiğinde hayatınıza rahatça dahil olur.

Yeni bir yıl, her şeyi baştan değerlendirme fırsatı sunuyor. Ama unutmayalım ki değişim sadece hayallerle değil, somut adımlarla gelir. Bu yazıda, zamanı nasıl daha iyi yönetebileceğinizi konuşacak ve 2025’i hayatınızın en üretken yılına dönüştüreceğiz.
Bir düşünelim: Eğer zamanınızı kontrol altına alabilirsek, hayatımızı da kontrol altına almış olmaz mıyız? Hadi gelin, bunu nasıl başarabileceğimizi birlikte keşfedelim 🔑.

Zaman Neden Kaçar Gibi Geliyor?

Bir düşünün: Yeni yılın ilk günündesiniz. Karar listenizi hazırladınız, daha üretken, daha düzenli ve hedef odaklı bir yıl geçirmek istiyorsunuz. Ama birkaç gün ya da hafta sonra bu heyecan kayboluyor. Kendinizi, 2024’teki aynı döngülerin içinde buluyorsunuz. Peki, neden?

Zamanı kontrol edemiyor gibi hissetmek çoğumuzun yaşadığı bir durum. Eminim bunun sebebi, dikkatimizi dağıtan bir işler ve yanlış alışkanlıklar yatıyor. Stanford Üniversitesi’nin yaptığı bir araştırma, insanların gün boyunca sürekli dikkatlerinin dağılmasının üretkenliği %40 oranında düşürdüğünü gösteriyor.

Bu durumdan kurtulmak için önce farkındalık geliştirmeliyiz. Zamanı kontrol etmenin sırrı, onun neden kayıp gittiğini anlamaktır. Dağınık bir masa, sürekli çalan telefon bildirimleri veya planlamanın eksikliği… Bunlar, zamanı düşman gibi hissettiren unsurlardır. Ancak bu düşmanı dostunuza çevirmek mümkündür 💪.

Doğru Ortam, Doğru Başlangıç

Her başarı bir başlangıçla başlar, ama bu başlangıcın gücü, çevrenizle doğrudan ilişkilidir. 2025’te sadece yeni kararlar değil, yeni bir düzen de oluşturmanız gerektiğini unutmayın.

Çevremiz genellikle üretkenliğimizin sessiz düşmanıdır. Karışık bir masa, dikkatinizi dağıtan bildirimler, huzursuz bir ortam… Bunlar, işlerinize odaklanmanızı engeller.

Bu değişimi başlatmak isterseniz, şu adımları izleyebilirsiniz:

• Belirli bir çalışma alanı seçin: Bir masanız, bir odanız veya sevdiğiniz bir kütüphane olabilir 📚.
• Ritüeller oluşturun☕: Örneğin, her sabah kahvenizi içerken o günün planını yapabilirsiniz. Küçük alışkanlıklar, büyük düzenlerin temelini oluşturur. (Tam olarak hatırlamasam da, bir yazarın sabahları çalışmaya başlamadan önce her zaman bir pipo içtiğini duymuytum. Tabii siz benim gibi tütün ürünleri kullanmayın 😅 )

Şimdi bir başlangıç yaptığımıza göre, Youtube’da rastladığım bir yöntemi anlatayım: Üç Şapka Kuralı.

Üç Şapka: Mühendis, İşçi ve Yargıç

Zaman yönetimi aslında bir role-play oyununa benzer 🎮. Her gün üç farklı şapka takmalısınız:

• Mühendis Şapkasını Takın: Planlamacı Olun
Güne başlarken mühendis gibi düşünün 🧠. Hangi görevlerinizi tamamlamak istediğinizi netleştirin ve bunlar için makul süreler belirleyin. Parkinson Yasası’nı duydunuz mu? Bu yasa, bir işin ona ayrılan süre kadar uzayacağını söyler. Örneğin; bir ödev için size 1 ay süre verilirse, o ödev ne kadar kolay olursa olsun 1 ayda ancak biter.
Öneri: Trello, Notion veya Google Calendar gibi dijital araçları kullanabilirsiniz. Bu uygulamalar işleri görselleştirmenize ve sıraya koymanıza yardımcı olur.

• İşçi Şapkasını Takın: Çalışmaya Başlayın
Plan yapmak yeterli değildir; çalışmaya başlamak gerekir. Ama nasıl? Motivasyon eksikliği bazen harekete geçmeyi zorlaştırır. İşte burada “5 Dakika Kuralı” devreye giriyor. Mel Robbins’in bu yöntemine göre, bir işe yalnızca 5 dakika başlamak bile genellikle uzun bir süreye dönüşür.
Newton’un eylemsizlik yasasını hatırlayın: “Hareketsiz bir obje hareketsiz kalmaya devam eder. Ama hareket eden bir obje, hareket etmeye devam eder.” Başlamak, devam etmenin en büyük tetikleyicisidir.

• Yargıç Şapkasını Takın: Kendinizi Değerlendirin
Günün sonunda, bir yargıç gibi değerlendirme yapın. Bu değerlendirme sadece işçiyi değil, mühendisi de kapsamalıdır. Kendinize şu soruları sorun:

• Mühendis olarak: Bugün kendime gerçekçi hedefler koymuş muydum? Önceliklerim doğru muydu? Planlama yaparken gözden kaçırdığım unsurlar nelerdi?

• İşçi olarak: Planladığım işleri ne kadar gerçekleştirdim? Hedeflerime ulaşmamı engelleyen şeyler nelerdi? Çalışma sürecimde dikkatimi dağıtan unsurlar var mıydı?

Bu tür bir değerlendirme, gelecekteki planlarınızın daha sağlam ve verimli olmasını sağlar.

“Değerlendirme olmadan gelişim olmaz.” — Peter Drucker

Somut Adımlarla Yeni Bir Başlangıç

Yeni bir başlangıç yapmanın heyecanı harikadır ama bu heyecan somut bir plana dönüşmediğinde hızla kaybolur. Bir yerde okuduğuma göre; Japonların yıl sonu temizlik ritüeli gibi bir şey yapıyorlarmış. Bizde bundan ilham alarak, zihinlerimizi de temizlemek adına bir adım atmaya ne dersiniz?

Bu bölümde, hedeflerinizi somutlaştırmanın ve günlük hayatınıza entegre etmenin yollarını bulacaksınız. Büyük hayallerinizi küçük, ulaşılabilir parçalara bölerek ilerlemenin ne kadar kolay olabileceğini göreceksiniz 🌟.

Son Söz: Kendi Yol Haritanızı Çizin

Son bir not: Takvimler 2025’i gösteriyor. Ama unutmayın, bir yıl sadece takvimde değişen bir rakamdan ibaret olabilir ya da sizin için hayatınızın en anlamlı dönüm noktası haline gelebilir. Bunun tamamen sizin elinizde olduğunu biliyor musunuz?
2025, olmayı seçtiğiniz kişi için bir başlangıç olabilir 🌟. Bu yıl zamanı bir düşman değil, bir müttefik olarak görmeye başlayın. Çünkü zamanı yönetmek, hayatınızı yönetmektir.

Mutlu Yıllar! 🎊🎉
Ek olarak: Zaman yönetimiyle ilgili daha fazla bilgi almak istersen, aşağıdaki kaynakları inceleyebilirsin:

• David Allen: Getting Things Done
• Stephen Covey: 7 Habits of Highly Effective People
• Brian Tracy: Eat That Frog!
• Parkinson’s law or The pursuit of progress

Yeni Bir Yıl, Yeni Bir Başlangıç

REFERANSLAR

https://repository.lib.kit.ac.jp/repo/repository/10212/2284/D1-0761_h1.pdf

Clean Architecture provides a framework for writing maintainable and testable code in Android projects. When building an application, getting the code architecture right is as critical as getting the building blocks right. The code architecture determines how the software will evolve, maintain and debug. Choosing the wrong architecture can lead to complexity as the project grows, and as a result can lead to wasted time and cost. For example, if you use an MVC (Model-View-Controller) architecture in a project, over time the Controller layer may become overloaded. In this case, the boundaries between business logic, user interface and data access layers become blurred. Clean Architecture prevents such problems and makes the code more maintainable and long-lasting.

We can liken this architecture to a building structure. Just as a building built on solid foundations will stand for years, a well-constructed architecture ensures that your project will remain solid in the long term. Just as a building with a weak foundation is bound to collapse after a while, a project with a complex and disorganized architecture will cause more problems as it grows. Clean Architecture separates the project into layers, making each component independent and testable.

Testability, Modularity and Sustainability: Key Benefits of Clean Architecture

One of the biggest advantages of Clean Architecture is testability. Dividing the code into different layers ensures that each layer can be tested independently. This makes debugging easier and ensures a reliable software development process. So why is testability so important?

Unit tests form the heart of the project. It makes it possible to test each layer by isolating its external dependencies. This minimizes the possibility of making mistakes. For example, if a developer is having problems between the business logic and data layers, it is easier to test both layers in isolation. Mocking frameworks (e.g. Mockito) allow dependencies to be isolated and show how these structures fit in with modularity. With modularity, each component can work on its own, increasing the reliability of your application.

Clean Architecture also offers great advantages in terms of modularity. Structuring code in layers makes it easy to add new features to the project. Imagine you have an application and you want to make a small update to the user interface. If your application is modular, you can make changes only in the relevant layer without affecting other layers. This speeds up the development process and improves software quality.

At the same time, maintainability means that your project adapts to the future. Clean Architecture keeps the code organized, making future improvements easier. Even if the code gets more complex as the project grows, developers using this structure have no difficulty understanding the overall structure of the application. New team members have less difficulty getting involved in the project and maintenance costs are reduced in the long run.

Fundamentals of Clean Architecture: Layered Structure

The basic philosophy of Clean Architecture is to separate the application according to responsibilities so that each part can work independently of each other. This way, changes made in one layer do not affect other layers. Clean Architecture consists of four main layers: Entity, Use Case, Interface Adapter, and Frameworks & Drivers. Let’s explain more clearly why and how each layer is used, as well as the responsibilities of each layer:

Entity Layer: This layer contains the most basic building blocks and rules of business logic. Entities are the most abstract components of the application and are isolated from the other layers. This isolation ensures that the core of the application is not affected by external factors.

For example, an entity representing a user could look like this:

data class User(
val id: Int,
val name: String,
val email: String
)

The User class contains basic information about the user. The data in this layer exists only to reflect business logic and is not dependent on external systems. This isolation ensures that business rules are always consistent.

Use Case Layer: Use cases are the layer that runs the business logic. It interacts with Entities to execute certain functions of the application. Use cases ensure that the functions that the application offers to users work in an organized and secure way.

For example, a use case that executes the process of saving the user could be like this:

class SaveUserUseCase(private val userRepository: UserRepository) {
fun execute(user: User) {
if (user.name.isNotBlank() && user.email.isNotBlank()) {
userRepository.saveUser(user)
} else {
throw IllegalArgumentException("Invalid user data")
 }
 }
}

“The SaveUserUseCase” class validates the data before saving the user and saves only valid users. This business logic is completely UI and database independent.

Interface Adapter Layer: This layer allows data to pass from one layer to another. For example, data from business logic is converted into a format suitable for the UI. This layer acts as a bridge between the outside world and the business logic of the application.

For example, a repository can be defined as follows:

class UserRepositoryImpl(private val database: UserDatabase) : UserRepository {
override fun saveUser(user: User) {
database.insert(user)
 }
}

This code abstracts the process of registering a user in the database. The business logic does not deal with the details of the database; it just uses this adapter to register the user.

Frameworks & Drivers Layer: This outermost layer contains external dependencies (APIs, databases, system tools). These dependencies do not affect other layers of the application.

For example, we can make an API call with Retrofit as follows:

interface ApiService {
@POST("users")
suspend fun createUser(@Body user: User): Response<User>
}

This layer manages integrations with external resources and prevents other layers from being dependent on external systems.

Each layer has a specific responsibility and a clear separation of these responsibilities makes the code easier to manage and maintain. If the responsibilities between layers become unclear, it becomes very difficult to debug a project and add new features. Clean Architecture makes the software development process more efficient by clearly defining the role of each layer.

Why the Need? Management Issues in Complex Projects

Android projects often start small, but as they grow over time, code management becomes difficult and complex. The lack of a layered structure leads to increased dependencies between different parts of the code. This creates major problems when a new feature is added to the project or when debugging. For example, if you want to change the function of just one button in an application, the whole project can be affected. Because certain parts of the code are tightly coupled to each other, a small change in one part can create unexpected errors in another part.

Thanks to the layered structure, each layer can be managed and modified independently. For example, if you want to change database operations, you only make changes to the Frameworks & Drivers layer. This solves your problem without affecting the rest of the application. This is a big advantage for both the developer and the sustainability of the project.

Future Architectural Design Trends: The Rise of Clean Architecture in Android Projects

As technology is constantly changing, software architectures are also evolving. Clean Architecture is becoming an increasingly preferred structure, especially in large and complex projects. Developers are starting to adopt Clean Architecture to increase the maintainability of their projects, ensure testability and provide a better user experience. With the rise of this trend, more and more projects in the software world will be implemented using this architecture.

As a result, Clean Architecture is becoming an indispensable tool in modern Android development. It simplifies the management of projects, increases testability and ensures long-term sustainability, making software development processes more efficient. By choosing the most appropriate architecture for your project, you can increase your chances of fewer problems and more success in the future.

for Turkish

Bibliography:

• From Junior to Senior: Modularization in Clean Architecture Android projects
• How Clean Architecture in Android can help for an Efficient Estimation
• What is Clean Architecture - Dotnet Copilot

https://youtu.be/KmnEsiQdd0M

https://youtu.be/uKlstDh_wLA

https://youtu.be/K1aC7eO6vbw

Android alanında kendini geliştirmek isteyenlerin sorduğu ilk soru genellikle “hangi dil ile başlamalıyım” olur. Bunun cevabı kişiden kişiye değişmekte. Ben bu sorunun cevabını araştırdığımda aslında net bir cevabının olmadığını ve ne kadar Kotlin çoğunlukta olduğunu görsem de farklı kodlama dillerinin de olduğunu fark ettim. Bu kararı vermek için dillerin farkının ne olduğunu, neden o dili seçmem gerektiğini öğrendim ve bunu sizle de paylaşmak isterim ama öncelikle Kotlin ve Java hakkında biraz bilgi edinmemiz gerek.

Java

Java, Sun Microsystems tarafından geliştirilen ve şu anda Oracle Corporation tarafından sürdürülen bir programlama dilidir. Nesne yönelimli bir yapıya sahiptir, yani programlamada nesneleri kullanarak modüler ve sürdürülebilir kodlar oluşturmanıza olanak tanır.

İşte Java’nın bir kaç özelliği:

Platform bağımsızlığı

“Write Once, Run Everywhere”(Bir kez yaz, her yerde çalıştır) ilkesi, Java’nın önemli bir özelliğidir ve Java’nın taşınabilirliği ile ilgili bir prensiptir. Bu özellikten biraz bahsedelim.

Java programları yazıldıktan sonra Java Derleyicisi tarafından Java Bytecode’a dönüştürülür. Bu bytecode, Java Sanal Makinesi (JVM) üzerinde çalıştırılabilir. JVM, farklı işletim sistemleri için mevcut olduğundan, Bytecode’un farklı işletim sistemlerinde çalışması sağlanır.

Exception handling

Java’da exception handling, programların çalışırken ortaya çıkabilecek hataları kontrol altına almayı ve bu hatalarla başa çıkmayı sağlar. Bir hata meydana geldiğinde program normal akışını sürdüremeyecek duruma gelirse, bir exception (istisna) fırlatılır ve bu istisna uygun şekilde işlenmelidir.

Exception handling, try-catch blokları kullanılarak gerçekleştirilir. Kod parçaları try bloğu içine yerleştirilir ve bu blokta hata olabilecek kodlar bulunur. Eğer bir hata meydana gelirse, programın çalışmasını durdurmadan catch bloğu devreye girer ve hata işlenir.

Zengin kütüphanesi ve kullanıcı desteği

Java’nın kütüphanesi, veri yapılarından ağ programlamaya, grafik arayüzlerinden dosya işlemlerine kadar geniş bir yelpazede hizmet verir. Örneğin, java.util paketi veri yapıları ve koleksiyonlar için birçok sınıf içerirken, java.net paketi ağ programlaması için gerekli sınıfları sağlar. Swing ve JavaFX gibi kütüphaneler ise grafiksel kullanıcı arayüzü (GUI) geliştirmeyi destekler.

Java günümüzde hala sık kullanılan bir dildir. Bu sebepten Java öğrenmeye başlayan birsi geniş bir kullanıcı kitlesinden faydalanabilir

Nesne yönelimli programlama

Java, nesne yönelimli programlama (OOP) paradigmasına tam uyumlu olarak tasarlanmış bir programlama dilidir. OOP, kodun nesneler ve sınıflar aracılığıyla organize edilmesini sağlar, bu da kodun daha okunabilir, yönetilebilir ve yeniden kullanılabilir olmasını sağlar. Java’da her şey nesneler ve sınıflar üzerine kuruludur, kalıtım, kapsülleme, polimorfizm ve soyutlama gibi OOP prensiplerini tam olarak destekler. Bu özellikler, Java’nın geniş çapta kullanılmasını ve büyük ölçekli yazılım projelerinde tercih edilmesini sağlar.

Kotlin

Kotlin Java Sanal makinesi (JVM) için tasarlanmış ve geliştirilmiş bir dildir. Bu sebepten Kotlin Java’nın güçlü özelliklerini ve yeteneklerini korurken, daha modern ve kullanışlı bir dil olarak tasarlamıştır. Kotlin web sitesinde bu durumu 3 kelime ile açıklar; modern , concise and safe.

Kotlin’in öne çıkan özellikleri aşağıdaki gibidir

Syntax ve Smart cast

Kotlin basit bir Syntax’a sahiptir. bu sayede kodlar rahatça anlaşılabilir ve yazılabilir. Değişkenleri otomatik olarak typecast etme özelliği sayesinde manuel olarak yazma ihtiyacını oldukça azaltır. Bu özellikler programcının işini oldukça kolaylaştırır

Nullability

Kotlin’in en önenmli yanlarından birisi Null güvenliğini sağlamasıdır

Bu örnekte, main fonksiyonunda checkNull fonksiyonu çağrılırken, null kontrolü doğrudan if ifadesi içinde gerçekleştirilmiştir. checkNull fonksiyonu, nullable olan bir String değerini parametre olarak alır (value: String?) ve null kontrolü yapar. Eğer değer null değilse "Değer: ..." şeklinde bir yazı döndürür, eğer null ise "Değer null" yazısını döndürür.

Coroutine

Kotlin’deki coroutines (korumalı işlemler) çok güçlü bir konudur ve asenkron programlamayı kolaylaştırır. Coroutines, uzun sürecek işlemleri veya yoğun işlem gerektiren görevleri arka planda çalıştırırken ana programın bloke olmasını engeller.

Bu örnekte runBlocking ile bir coroutine scope oluşturuyoruz. launch fonksiyonuyla yeni bir coroutine başlatıyoruz ve readDataFromFile isimli suspend fonksiyonunu çağırıyoruz. Bu fonksiyon içinde withContext kullanarak dosya okuma işlemini arka planda çalıştırıyoruz.

Coroutine’ler, asenkron işlemleri yönetmek için oldukça kullanışlıdır ve Kotlin’in bu özelliği sayesinde asenkron programlama daha okunabilir ve yönetilebilir hale gelir.

Java ile uyumu ve kütüphane paylaşımı

Kotlin yaratılırken Java’nın güçlü yönlerini alıp üzerine iyi geliştirmeler yapılmıştır. Bununla birlikte kotlin kodunuzda bir Java kütüphanesini sorunsuz bir şekilde kullanabilirsiniz.

Kotlin’in ve Java’nın öne çıkan özellikleri böyleydi. Şimdi Kotlin ve Java’yı karşılaştırarak farklarını biraz daha anlayalım.

Karşılaştırma

Java ile Kotlin’in farklarını listeleyecek olursak akla gelen başlıklar şunlardır:

1- Syntax

Kotlin’in Syntax’ı Java’ya kıyasla çok daha özgündür. Bu yüzden okunabilirliği ve daha kolay

yazılmasıyla Java’dan daha kullanışlı olduğu söylenebilir.

Aşağıda Java diliyle tanımlanmış bir class, bu class’da tanımlanmış private bir parametre ve birkaç degişken görmekteyiz.

Burada ise aynı kodların Kotlin’deki karşılıkları;

Buna ek olarak Kotlin’de değişken türünü açıkça belirtmeniz gerekmez. Compiler bunu bizim için yapmakta.

Java’da ise değişkenin türünü açıkça yazmalısınız. Bu kodunuzu daha ayrıntılı hale getirecektir.

“Kotlinin özelliklerinden biri güçlü bir tipleme ve nullability özelliklerinin iyi bir kombinasyonudur”

Mark Zaslavskiy, ITMO üniversitesi

2- Scabality(Ölçeklenebilirlik)

Java gibi diller genellikle büyük projeler için kullanılırken bu dillerin yapısal özellikleri sebebiyle ölçeklenebilirlikleri sınırlı olmaktadır. Özellikle büyük projelerde bu durum uygulamanın şişmesine (bloat) ve performans düşüklüklerine neden olabilir.

Koltin’de ise durum öyle değil. modern bir dil olarak ölçeklenebilirliğe daha fazla odaklanmıştır. Daha basit ve temiz sözdizimi geliştiricilerin kodu daha etkili bir şekilde yönetilebilmesini ve ölçeklendirilmesini sağlar.

3- NPE (NullPointerException)

Örnekteki gibi Java’da boş bir değişken tanımladığınızı düşünelim ve bu değişkeni kullanalım.

Burada “nullPointException” hatası alacaksınız. Bir değişkenin null olma ihtimaline karşı Java’da şu şekilde tedbir alınır:

Bu kodun satır sayısını arttırdığı gibi devamlı bu tür ‘if-else’ blokları açmak kodun okunabilirliğini düşürecek ve performansını azaltacaktır.

‘If-else ’bloklarının avantajı ise programcıya esneklik sağlaması. Değişkenin “null” olma durumunda farklı bir işlem yapmak istenirse bu ‘if’ bloğuna ekleyebilir.

Kotlin’de ise durum şu şekilde ;

Kodun karmaşasının ne kadar azaldığını görmüşsünüzdür. Bununla birlikte Java’da bahsettiğimiz esneklik aynı şekilde burada da geçerli, üstelik sadece isteğe bağlı;

4- Lambda

Kotlin’de lambda kullanımı daha basittir. Örnek bir kodu şu şekilde gösterebiliriz;

Javada ise lambda kullanımı daha karmaşık ve daha az okunabilir düzeydedir. Örnek bir kod göstermek gerekirse:

5- Fonksiyonel operatörler ve yüksek seviyeli fonksiyonlar:

Kotlin fonksiyonel programlama paradigmalarını destekler. Bu konuda javadan daha iyidir

Kotlin’de ‘filter’, ’map’, ’reduce‘ gibi işlevsel operatörler ve yüksek seviyeli fonksiyonlar kullanılabilir

Java’da ise fonksiyonel operatörler ve yüksek seviyeli fonksiyonlar lambda ifadeleri ve Stream API gibi özelliklerle sağlanır ancak Kotlin’e göre daha karmaşık ve kullanımı daha az doğaldır

Hangisi kullanılmalıdır? Bu sorunun cevabı kişiden kişiye ve ilerlemek istediğiniz alana göre değişir. Bununla birlikte Android geliştirici olmak istiyorsanız önceliğiniz Kotlin olmalı. Hem daha modern bir dil hem de artık Kotlin çok daha öncelikli

Teşekkürler…

Kaynakça:

https://learningdaily.dev/kotlin-vs-java-which-programming-language-should-you-learn-0506f9a49612

• Kotlin vs. Java: A Comprehensive Analysis for Modern Development
• Kotlin Programming Language

https://www.freecodecamp.org/news/kotlin-vs-java-whats-the-difference/