Android-links

Manually curated collection of links about android development, developer work and life, that I found useful/interesting.

Jump to

• Android
  • Views
  • Context
  • Fragment
  • Service
  • Themes
  • Gradle
  • Architecture
  • IDE
  • Other
• Programming language
  • Kotlin
  • Java
• Software development
  • OOP
  • Design patterns
  • Tests
  • Git
  • Developer Work
  • Developer Life
• Libraries
  • Rx
  • DI
  • Other Libraries

Android

Views

back to top

• Main
  • Animating Android Activities and Views with Left and Right Slide Animations
  • ConstraintLayout - Guidelines, Barriers, Chains and Groups
  • Playing with elevation in Android
  • Drawing multiline text to Canvas
  • Spantastic text styling with Spans
  • Customizing Switch using XML
  • [Youtube] View only Android apps at scale
  • Rich text battle: TextView vs WebView
  • A guide for Android ImageView ScaleType and adjustViewBounds
  • ViewPager without fragments
  • Introduction to SpringAnimation with examples
  • -nodpi, -anydpi, and WTF?
  • TransitionDrawable — Small Gems of the Android Framework
  • Preferred way to set clickable image icon
  • Selectively Locking An Android UI
  • [Yotube] Loving Lean Layouts
  • Implementing Custom Drawables
  • How to maximize Android’s UI reusability — 5 common mistakes
  • State of the Navigation Drawer
  • On the Bottom Navigation Bar
  • You thought you knew Android
  • Parallax Scrolling
  • Resolving View Attributes on Android
  • ConstraintLayout Flow: Simple Grid Building Without Nested Layouts
  • ConstraintLayout: Circular Positioning
  • How to Support Themes in Custom Views
  • Animating a strike through on Android
  • AnimatedIcons: Strikethru
  • Adventures in the Land of EditText
  • Better Custom Views with Delegates
  • ViewStub: On-demand inflate view or lazily inflate layout resource
  • The Lifecycle of a View in Android
  • Android’s ImageView scale type cheatsheet
  • NumberPicker
  • MotionLayout: Visibility
  • 2 Android components you should start using right now!
  • Material Slider
  • MaterialTimePicker
  • Controlling TextView MinWidth
  • [Youtube] Transitions without Activities or Fragments
  • Building a Segmented Progress Bar in Android
  • Sonar-like animation
• RecyclerView
  • Implementing a modal selection helper for RecyclerView
  • RecyclerView animations done right
  • Your ViewHolders Could Be Doing So Much More
  • ItemDecoration in Android
  • [Yotube] Mastering RecyclerView Layouts
  • RecyclerView — More Animations with Less Code using Support Library ListAdapter
  • Right way of setting margin on Recycler View’s cell
  • DiffUtil is a must
  • Saving Scroll Positions of Nested RecyclerViews
  • Glide'ing your way into RecyclerView state invalidation
  • RecyclerView Anti-Patterns
  • Nested recycler in Android done right!
  • Efficient lists with DiffUtil and ListAdapter
  • RecyclerView Item Change Animations With a Custom Item Animator
  • Paging Image Carousel with RecyclerView
• Dialogs
  • Exploring Android P: Fingerprint Dialog
  • Dialogs in Android: Practical Guide
  • What you might not know about the AlertDialog
  • Mastering Android Dialogs: Don’t follow official Google Guides
• WebView
  • Android WebView — Downloading Images
  • Android WebViews: All about security
  • Managing Keyboard on Webview
• Compose
  • Thinking in Compose
  • [Youtube] Jetpack Compose: Beta overview
  • Jetpack Compose: Modifiers fundamentals
  • Always provide a Modifier parameter
  • How to create a truly custom theme in Jetpack Compose
  • A Vocabulary of Jetpack Compose Terms
  • Loading images for Jetpack Compose using Glide, Coil, and Fresco
  • Remembering the State in Jetpack Compose
  • Things you need to know before switching to Jetpack Compose
  • Compose O'Clock
  • Jetpack Compose — Reveal effect
  • Instagram-like particles animation using Jetpack Compose
  • Building design system with Jetpack Compose
  • State and Jetpack Compose
  • Complete guide to Rich Text in Jetpack Compose
  • Dagger/Hilt vs Koin for Jetpack Compose Apps
  • Jetpack Compose: styling Text
  • Jetpack Compose with Lifecycle-Aware Composables
  • From View to Composable: A Quick jump to Jetpack Compose from an Android View mindset
  • Building an Authentication Form using Jetpack Compose
  • Promise compose compiler and imply when you'll change
  • Keyboard Handling In Jetpack Compose — All You Need To Know
  • How can I debug recompositions in Jetpack Compose?
  • Composable functions and return types
  • Compose remember vs remember mutableStateOf
  • Diving Into Compose — Lessons Learned While Building Maps Compose
  • Jetpack Compose Effect Handlers
  • Here's a productivity hack to save tens of engineering hours* when working with Jetpack Compose!
  • Lazy Grid layouts in Compose
  • Quick Note on Jetpack Compose Recomposition
  • Debugging and fixing a huge Jetpack Compose performance problem in my Sudoku-solver app
  • Jetpack Compose — When should I use derivedStateOf?
  • Jetpack Compose bottom sheet over Android view using Kotlin extension
  • Animating visibility vs alpha in Compose
  • Brushing up on Compose Text coloring
  • Drawing custom text spans in Compose UI
  • Organizing @Composables
  • Everything you need to know about Side Effects in Jetpack Compose with examples
  • 6 Jetpack Compose Guidelines to Optimize Your App Performance
  • Comparing Jetpack Compose performance with XML
  • Nested Auto Scroll For Section Based Lists With Jetpack Compose
  • A comprehensive guide to Android runtime permissions using Jetpack Compose
  • Exploring Jetpack Compose for Android TV: Carousel
  • Collapsing Toolbar in Jetpack Compose LazyColumn — Three Approaches
  • How to have multiple styles within Jetpack Compose Text
  • How to Handle Automatic Content Resizing when keyboard is visible in Jetpack Compose
  • Jetpack Compose Tutorial: Replicating Dribbble Audio App - Screen Transitions
  • Jetpack Compose: Switch
  • Adding animations to Google Maps in Jetpack Compose
  • How to build a time picker with Jetpack Compose
  • Create a custom Theme with Jetpack Compose
  • Consuming flows safely in Jetpack Compose
  • Customizing Compose Pager with fun indicators and transitions
  • Setting up ViewPager in Jetpack Compose
  • Implementing a circular carousel in Jetpack Compose
  • Creating Pager Animations in Jetpack Compose
  • Every single type of Dialog in Jetpack Compose and how to use them
  • ViewCompositionStrategy Demystified
  • Spring & Fling Animations with Jetpack compose

---

Context

back to top

• Which Context should I use in Android?
• Why Having Global Static References to Application Contexts is Probably not the Best Idea
• Android Context Needs Isolation
• Mastering Android context
• Using Context Theme Wrapper
• Everything about Context in Android? Understand how new right

---

Fragment

back to top

• Advocating Against Android Fragments
• Fragment Transactions & Activity State Loss
• The Dark side of Fragments
• Android Fragment Lifecycle for Professional Developers
• Lifecycle & Fragments backstack
• [Youtube] Life Without Fragments
• From Fragments to Activity: the Lambda Way
• Handling IllegalStateException: Can not perform this action after onSaveInstanceState
• Android Fragments: FragmentContainerView
• Android Fragments: FragmentFactory
• Fragment Lifecycles in the Age of Jetpack
• 7 Common Mistakes Easily Made with Android Fragment
• An update to the FragmentViewBindingDelegate: the bug we’ve inherited from AutoClearedValue

---

Service

back to top

• How to handle background services in Android O
• Exploring Background Execution Limits on Android Oreo
• Services. The life with/without. And WorkManager
• Mastering Android Service of 2018
• How to Service on Android — part 2
• The “misbehaving” foreground service in Android

---

Themes

back to top

• Android Themes & styles, a real architecture
• Android Resources Refactoring
• Styling Colors & Drawables, Theme Attributes
• Polishing UI: Android StateListAnimator
• [Yotube] Using Styles and Themes Without Going Crazy
• Android Styling: Themes vs Styles

---

Gradle

back to top

• Gradle Tutorial for Android: Getting Started
• [Yotube] Speeding Up Your Android Gradle Builds
• How to speed up your slow Gradle builds
• Renaming Your Gradle Build Files
• [Yotube] Gradle: From User to Addict
• Experimenting with Gradle dependencies
• Speed Up Your Android Project's Gradle Builds
• 19 tips for Gradle in Android projects
• Tame Your Gradle Dependencies just because!
• Protecting secrets in an Android project
• A Bit of Gradle Housekeeping
• The Importance of Validating the Gradle Wrapper
• TOML + Gradle + project accessors
• Integrate Version catalog in Android
• Strategies for managing Gradle dependencies
• Impact of Dependency Tree Depth on Gradle Builds
• Different ways to handle Android Gradle dependencies
• sourceCompatibility, targetCompatibility, and JVM toolchains in Gradle explained
• Gradle Basics for Android Developers

---

Architecture

back to top

• Architecture Components
  • Android Architecture Components
  • Introduction to Android Architecture Components
  • Architecture Components - I'm not a purist but
  • Background and Foreground events with Android Architecture Components
  • [Video] Clean App Design with Architecture Components
  • 5 common mistakes when using Architecture Components
  • Architecture Components & MVP \ MVVM
  • A WorkManager Pitfall: Modifying a Scheduled Worker
  • Workout your tasks with WorkManager
  • Encapsulating View State
  • Architecture Components pitfalls
  • SavedStateHandle to the Rescue
  • Paging3 — Doing Recyclerview Pagination the Right Way
  • The curious case of crashing Workers
• ViewModel
  • Android ViewModel should be called scopedComponent
  • ViewModels: Persistence, onSaveInstanceState(), Restoring UI State and Loaders
  • ViewModels and LiveData: Patterns + AntiPatterns
  • ViewModels: State persistence — SavedState
  • When to load data in ViewModels
  • Should I use Jetpack ViewModel?
  • Dive deep into Android’s ViewModel — Android Architecture Components
  • Composite ViewModel
• LiveData
  • Concise Error Handling with LiveData and Retrofit
  • Using Realm with Kotlin and LiveData
  • When LiveData and Kotlin don’t play well together
  • Avoid backing properties for LiveData and StateFlow
  • When NOT to Use LiveData
• Navigation
  • AndroidX Navigation: Building on the Wrong Abstraction
  • How do we handle multi-modules navigation on our Android app
  • Structural and navigation anti-patterns in multi-module and modularized applications
  • Jetpack Compose navigation architecture with ViewModels
  • Modular navigation with Jetpack Compose
  • MULTI-MODULE NAVIGATION IMPLEMENTATION WITH OUR ANDROID TEAM
  • In-app navigation wih coordinators
• Other
  • Weighing in on the Holy Architecture War
  • Android Architecture Patterns Part 1: Model-View-Controller
  • Architectures of Android applications
  • Cargo Cult MVVM => The death knell of WPF
  • MVP to MVVM transformation
  • [Youtube] Android Software Architecture by Example
  • [Youtube] Half Way to clean architecture
  • [Youtube] Application Architecture: Designing Offline Application Case Studies
  • Netflix Shows The Future of Android Architecture
  • MVVM with architecture components: a step by step guideline for MVP lovers
  • Flexible way to handle exceptions in Android
  • MVI - The Good, the Bad, and the Ugly
  • Anemic Repositories, MVI and RxJava-induced design damage, and how AAC ViewModel is silently killing your app
  • MVC/MVP/MVVM/CLEAN/VIPER/REDUX/MVI/PRNSAASPFRUICC — building abstractions for the sake of building abstractions
  • Say no to BaseActivity and BaseFragment
  • Building An Application With MVVM
  • Multiple ways of defining Clean Architecture layers
  • MVWTF: Demystifying Architecture Patterns
  • Repository Pattern: Properly Organizing Your Data Layer
  • Android: Error handling in Clean Architecture
  • Designing and Working with Single View States on Android
  • Thoughts about State Handling on Android
  • Finding the right abstraction (when working with Strings)
  • Repository initialization without StrictMode violations
  • Our Way to MVVMI and Mistakes We Made When Implementing MVVM
  • Architecture in Jetpack Compose — MVP, MVVM, & MVI
  • Traditional MVVM with Jetpack Compose and StateFlow
  • The ABC of Modularization for Android in 2021
  • Practical Modularisation for Android Developers
  • Domain-Specific Models
  • How To Avoid Use Cases Boilerplate in Android
  • The famous and unthought MVI misconception in Android, alongside MVVM
  • Adding a domain layer
  • Principles & Practice in Repository Layer
  • Interface Naming Conventions

---

IDE

back to top

• Live Template for RecyclerView Adapter in Android Studio
• Add Logs Without Using Code
• Bringing more colour to Android Studio
• Using Live Templates to Write Tests
• Android Memory Profiler
• git rm --cached ./idea?
• Add custom live templates in Android Studio
• Split layouts into subfolders in Android Studio
• Android Studio Design Tools UX — Split View
• Scratch That Itch
• TODO Live Templates
• Accommodate your project-specific needs with custom templates
• Background Task Inspector
• Debugging like a pro in Android Studio
• Android Debugging
• Android Developer Options that you probably forgot
• Spot your UI jank using CPU profiler in Android Studio
• My Top 7 Most Underrated IntelliJ IDEA Features
• Things you can do in Android Studio
• Quick tip: finetune your Android Studio and IntelliJ Welcome screen
• Android Studio's "I'm Feeling Lucky" Button
• See Crashlytics issue reports directly in Android Studio with App Quality Insights

---

Other

back to top

• Main
  • Identifying an Android Device
  • Streamlining eero’s Android build process
  • An introduction to Android Instant Apps
  • Android Task and Back Stack Review
  • Going multiprocess on Android
  • Exploring the Android EmojiCompat Library
  • Optimizing the Performance of Vector Drawables
  • Task Stack
  • Understanding Activity.runOnUiThread()
  • Safe-Integration of Realm in Android production code
  • How to Correctly Store App-Specific Files in Android
  • Sharing Content between Android apps
  • Exploring the Android App Bundle
  • [Yotube] Timing is Everything: How to use Timer, Handler, and AlarmManager
  • [Yotube] Requesting Permissions at Run Time
  • [Yotube] How the Main Thread works
  • [Yotube] Exploring Custom Activity Transitions
  • [Yotube] Tools of the Trade
  • [Video] Exploring the Activity Lifecycle
  • TransactionTooLargeException on Nougat solved
  • Large Database Queries on Android
  • Realm — It’s all about the choices we make
  • Understanding Android Core: Looper, Handler, and HandlerThread
  • Understanding Android Matrix transformations
  • Developing Secure Android Apps
  • Unwrapping Framework Binding Adapters
  • Android CPU, Compilers, D8 & R8
  • [Yotube] From AlarmManager to WorkManager
  • [Yotube] Working Effectively with (Android) Legacy Code
  • A Little Thing about Android Module Paths
  • Understanding Activity Aliases in Android To Preserve Your Launchers
  • [Yotube] Understanding Android's Message Queue
  • Understanding the Application Lifecycle in Android
  • Saving secrets with buildSrc
  • Holiday clean up or cute versioning in android
  • Divide and conquer
  • TimingLogger: An idiomatic Android approach to measuring execution time
  • Android ProcessLifecycleOwner by example
  • Coil vs Picasso vs Glide: Get Ready… Go!
  • How to Use Shared Element Transition with Glide in 4 steps
  • Hidden mistakes with Shared Element Transitions
  • Don’t use Base64 encoded images on mobile
  • Mobile App Versioning: A Numbers Game
  • Beyond Gson — Evaluating JSON Parsers for Android & Kotlin
  • Simple Guide to Android Product Flavors
  • Encrypting Shared Preferences with the AndroidX Security Library
  • Reduce Overdraw from Your Android Application
  • Showing the Android Keyboard Reliably
  • Data Encryption on Android with Jetpack Security
  • Evolution of Finding Views by ID in Android
  • App Standby Buckets In Android
  • Make Android View Binding great with Kotlin
  • The First 2 Commits Every Android Project Should Have
  • 8 Valid Reasons for Modularization in Android
  • 5 Most Popular Package Structures for Software Projects
  • Low-level implementation of array
  • Android Logging on Steroids: Clickable Logs With Location Info
  • Easy Android Scopes
  • The Bifurcation Of Android
  • Remote logging with Timber and Firebase Realtime Database
  • A few experiments with Android drawable gradients
  • Assets or Resource Raw folder of Android?
  • Android Widgets
  • Simple one-liner ViewBinding in Fragments and Activities with Kotlin
  • Data Binding — Lessons learnt
  • Dark Theme with MDC
  • Supercharge Android dev with Scrcpy and ADB WIFI
  • Building on the Wrong Abstraction
  • Android ImageView AdjustViewBounds Demystified
  • Busting Android performance myths
  • Android WiFi Scanning Frustrations
  • Modern Android Security Development
  • The Ultimate Guide to Android Bluetooth Low Energy
  • All you need to know about ArrayMap & SparseArray
  • Understand the types of Launch Modes in an Android Activity
  • Demystifying Locale on Android
  • Keeping Secrets Safe in Android Projects
  • [Youtube] Trash Talk: The Evolution of Android Garbage Collection
  • Android Runtime — How Dalvik and ART work?
  • Decrease memory usage of your Android app in half
  • Measure and optimize bitmap size using Glide or Picasso
  • From zero to hero: Optimizing Android app startup time
  • All About PendingIntents
  • Delay with respect of lifecycle
  • Detect Screenshots in Android
  • Insecure TLS Certificate Checking in Android Apps
  • Integrating detekt in the Workflow
  • Reverse Engineer Your Favorite Android App
  • Accessing App Usage History In Android
  • The Case of the Disappearing Days
  • Two targets, one arrow: Cutting down our app size and startup time on Android
  • All about Preferences DataStore
  • Using DataStore With Kotlin Serialization
  • Android Vitals - Diving into cold start waters
  • When “Compat” libraries won’t save you
  • How OkCredit Android App improved Cold Startup by 70%
  • Memory Leaks in Reactive Android Programming
  • Ten #AndroidLifeHacks You Can Use Today
  • Making Sense of Intent Filters in Android 13
  • Migrate The Deprecated OnBackPressed Function — Android 13
  • 3 Ways to Secure Secret Keys in Android
• Net
  • Various methods to debug HTTP traffic in Android applications
  • Four Ways to Bypass Android SSL Verification and Certificate Pinning
  • Securing Network and Inter-App Communications on Android
• ProGuard
  • Practical ProGuard rules examples
  • Troubleshooting ProGuard issues on Android
  • [Yotube] Bulletproof Android
  • Is Your Kotlin Code Really Obfuscated?
  • Android's Built-in ProGuard Rules: The Missing Guide
  • Understand Proguard Generated Files and Manually De-obfuscate Stacktrace
• APK/Multidex
  • 65K methods
  • Android APK signature scheme v3
  • Use the Android apk analyzer to reduce your apk size
  • Comparing APK sizes
  • [Yotube] Understanding and Experimenting with MultiDex
  • My Journey on Reducing APK size at GetMega
• Memory leak
  • What you need to know about Android app memory leaks
  • Android leak pattern: subscriptions in views
  • Our battle with the OutOfMemory army
  • Reliable Hot Reload on Android
  • Detecting memory leaks in Android applications
  • Everything you need to know about Memory Leaks in Android
• Lint/Static analysis
  • [Yotube] Linty Fresh
  • Multi-module Lint Rules
  • Multi-module Lint Rules Follow Up: Suppressions
  • Enforcing Custom View Usage With Android Lint
  • Static analysis tools for Android
  • Kotlin Static Analysis — why and how?
  • Compiler Warnings Are Good, Actually
  • Increasing Android Lint Terminal Results
  • Automation of code analysis in Android projects
• Room
  • Understanding migrations with Room
  • Room auto-migrations
  • Android Room Hidden Costs

---

Programming language

Kotlin

back to top

• Data Classes
  • Creating multiple constructors for Data classes in Kotlin
  • Representing View State with Kotlin Data Classes
  • Data Classes are The Best Kotlin Feature
  • Kotlin data classes and sensitive information
  • Data classes aren't (that) magical
  • Kotlin for Android Developers: Data Class
  • Prefer Data Classes Over Pairs
• Sealed Classes
  • Modeling ViewModel States Using Kotlin’s Sealed Classes
  • Simplify your Android code by delegating to sealed classes
  • Kotlin Sealed Classes — enums with swag
  • Kotlin pearls: Sealed Class Override
  • Abstracting Kotlin Sealed Classes
  • You may not need a sealed class
  • Enum vs Sealed class — which one to choose?
  • Dealing with Multiple APIs via Retrofit? Learn How to use Sealed Classes Effectively
• Delegates
  • Kotlin is Dope And So Are Its Custom Property Delegates
  • Kotlin — Faster Lazy for Android
  • The magic in Kotlin: Delegates
  • Kotlin delegates in Android development
  • Simpler Kotlin class hierarchies using class delegation
  • Under the hood of Kotlin Class Delegation
  • Advanced Kotlin - Delegates
  • Effective Class Delegation
• Type System
  • Kotlin Type Hierarchy
  • Nothing (else) matters in Kotlin
  • Kotlin’s ‘Nothing’ Type
  • The Ins and Outs of Generic Variance in Kotlin
  • Kotlin — Mastering generics nullability
  • All About Type Aliases in Kotlin
  • An Illustrated Guide to Covariance and Contravariance in Kotlin
  • Null is your friend, not a mistake
  • Kotlin’s Nothing: Its Usefulness in Generics
  • Understanding Kotlin limitations for type parameter positions
  • Any, Unit, Nothing and all their friends
  • The power of types for errors
  • JvmSuppressWildcards: The secret sauce to your sandwich-style generics
• Properties
  • Kotlin and Android — Treacherous properties
  • Kotlin: should I define Function or Property?
• Android
  • How kotlin became our primary language for android
  • Starting Activities with Kotlin
  • Kotlin + buildSrc for Better Gradle Dependency Management
  • The danger of assumptions: Kotlin with Android custom views
  • A Better Way to Launch Activities on Android
  • Hacking Architecture Components by using Kotlin
  • [Video] Advancing Android Development with Kotlin
  • Custom attributes using BindingAdapters in Kotlin
  • Kotlin Android Extensions: Using View Binding the right way
  • Making the Android Studio Layout Editor Better With Kotlin
  • Kotlin for Android Developers: Visibility Modifiers
  • JvmOverloads for Android Views
  • Misconception about Kotlin @JvmOverloads for Android View Creation
• Coroutines
  • [Youtube] Asynchronous Programming with Kotlin
  • Coroutines: first things first
  • Simple asynchronous loading with Kotlin Coroutines
  • Concurrent coroutines - concurrency is not parallelism
  • Android Kotlin Coroutine Best Practices
  • Launching a Kotlin Coroutine for immediate execution on the Main thread
  • Cancelling Kotlin Coroutines
  • How to make sense of Kotlin coroutines
  • Kotlin Coroutines @ Vimeo
  • Kotlin Coroutines patterns & anti-patterns
  • Mastering Coroutines. Android. Unit Tests
  • Managing exceptions in nested coroutine scopes
  • Kotlin Coroutines on Android: Things I Wish I Knew at the Beginning
  • [Youtube] Structured concurrency
  • Preventing coroutine cancellation for important actions
  • Shared mutable state with Coroutines
  • Suspending over Views — Example
  • The suspend modifier — Under the hood
  • Coroutines and exceptions: things to know
  • Comparing Kotlin Coroutines with Callbacks and RxJava
  • Understanding Kotlin Coroutines with this mental model
  • Cancellation in coroutines
  • Demystifying CoroutineContext
  • Exceptions in coroutines
  • Coroutines & Patterns for work that shouldn’t be cancelled
  • Why exception handling with Kotlin Coroutines is so hard and how to successfully master it!
  • Advanced Kotlin Coroutines tips and tricks
  • Kotlin Coroutines in Android Summary
  • Network Fetch with Kotlin Coroutine
  • Kotlin Coroutine Scope, Context, and Job made simple
  • Best practices for coroutines in Android
  • 7 common mistakes you might be making when using Kotlin Coroutines
  • 7 Gotchas When Explore Kotlin Coroutine
  • Do I need to call suspend functions of Retrofit and Room on a background thread?
  • Use suspendCoroutine to connect callbacks and coroutines
  • Coroutine suspend function: when does it start, suspend or terminate?
  • Misnomers, Mistakes and Misunderstandings to watch for when learning Kotlin Coroutines and Flow
  • Are You Handling Exceptions in Kotlin Coroutines Properly?
  • Why using Kotlin Coroutines?
  • Kotlin coroutines, threads, concurrency and parallelism 101
  • Job and children awaiting in Kotlin Coroutines
  • Coroutine scope functions
  • Channel in Kotlin Coroutines
  • Coroutines racing! Why, and how
  • Safe delay in Android Views: goodbye Handlers, Hello Coroutines!
  • Coroutine Misconceptions: Whose Context Is It Anyway?
  • Leveraging the Semaphore concept in Coroutines to limit the parallelism
  • Awaiting Multiple Coroutines the Clean Way
  • Understand Android Lifecycle Aware Coroutine Scope Made Easy
  • Things every Kotlin Developer should know about Coroutines. Part 2: CoroutineScope
  • Slowing down your code with Coroutines
• Functional Programming
  • Function references in Kotlin
  • Listeners with several functions in Kotlin
  • Comping with kotlin's scope functions
  • the tldr; on Kotlin’s let, apply, also, with and run functions
  • Kotlin Functional Programming: Does it make sense?
  • Lambda Expressions in Kotlin
  • Kotlin Standard Functions cheat-sheet
  • Kotlin: Function References
  • When to use Kotlin's standard functions
  • Be Explicit! Don’t Let Convenience Make Your Code Less Maintainable and Readable
  • How to use Kotlin's 'it also let apply run'
  • Noisy Code With Kotlin Scopes
  • Functional Domain Modeling in Kotlin
  • Functional Exception Handling With Try
• Extension Functions
  • How to Abuse Kotlin Extension Functions
  • Extensions: The Good, The Bad and The Ugly
  • Writing clean models using extensions
  • Factory or Extension Function?
  • Bad Kotlin Extensions
• Patterns
  • Gang of Four Patterns in Kotlin
  • Kotlin tips: Singleton, Utility Functions, group Object Initialization
  • DI for lazy kotliniers
  • Default implementations for interfaces
  • Kotlin Anti-Patterns - Also this is Null
  • Abstract class vs interface in Kotlin
  • Patterns in Kotlin: Abstract Factory
• Variable
  • A few facts about Companion objects
  • You don't need a variable for this
  • A practical explanation for initialization modifiers in Kotlin
  • Kotlin variable, to be Lazy, or to be Late?
• Sequences
  • Kotlin : Slow List and Lazy Sequence
  • Kotlin Sequences: An Illustrated Guide
  • Collections and sequences in Kotlin
  • Effective Kotlin: Use Sequence for bigger collections with more than one processing step
  • When to Use Sequences
• Flow
  • Into the Flow: Kotlin cold streams primer
  • Playing with Kotlin Flows
  • Back-pressure in Kotlin Flows
  • Going deep on Flows & Channels — Part 1: Streams
  • The Best Way to Collect a Flow in Kotlin – launchIn
  • A safer way to collect flows from Android UIs
  • Kotlin Flows ~ an Android cheat sheet
  • Avoid launchIn
  • MutableSharedFlow is kind of complicated
  • Backpressure in your Kotlin Flows
  • Kotlin flow: Nesting vs Chaining
  • Simplifying APIs with coroutines and Flow
  • StateFlow and SharedFlow: the new hot stream APIs in town
  • Substituting Android’s LiveData: StateFlow or SharedFlow?
  • Migrating from LiveData to Kotlin’s Flow
  • Making cold Flows lifecycle-aware
  • Kotlin’s Flow in ViewModels: it’s complicated
  • Do or do not; there is no tryEmit()
  • Kotlin SharedFlow or: How I learned to stop using RxJava and love the Flow
  • repeatOnLifecycle API design story
  • Safely collecting hot flows from Android native UI
  • Explore LiveData & StateFlow Value Emitting Behavior
  • Kotlin Flow Retry Operator with Exponential Backoff Delay
  • Retry Operator in Kotlin Flow
  • StateFlow and SharedFlow in ViewModels
  • callbackFlow - Callback to Flow API in Kotlin
• Other
  • Using Kotlin in a Java project: 10 lessons learned
  • How to remove all !! from your Kotlin code
  • Learning Kotlin by Mistake
  • Simplified code with kotlin
  • Safe, concise text parsing with regex destructuring in Kotlin
  • A life without ifs
  • Kotlin + Dagger 2 Gotchas
  • Demystifying the inline keyword
  • Looping in Kotlin
  • [Youtube] Kotlin in Production
  • What is “concurrent” access to mutable state?
  • API Design — Handling exceptions
  • Moving forward with Kotlin: Inheritance
  • What you didn’t know about arrays in Kotlin
  • Kotlin: For-loop vs ForEach
  • The Argument Over Kotlin Synthetics
  • Kotlin : When if-else is too mainstream
  • [Youtube] Advanced Kotlin
  • Those sneaky Kotlin Exceptions
  • Kotlin pearls: It’s an Object… It’s a Function… It’s an Invokable
  • Kotlin: Don’t just use LET for null check
  • The Mystery of Mutable Kotlin Collections
  • Java vs. Kotlin: Performance
  • [Kotlin Pearls 7] Unit, Nothing, Any (and null)
  • JvmDefault: More Useful Than You Think
  • Kotlin Enum Recipes
  • To val, or to const val, that is the question
  • Synchronization, Thread-Safety and Locking Techniques in Java and Kotlin
  • Public API challenges in Kotlin
  • Kotlin’s Assert Is Not Like Java’s Assert
  • Companion object invoke operator overloading for default constructor argument in generic classes
  • Uniform list access with subscripts
  • Kotlin’s vararg and spread operator
  • Equality in Kotlin (==, === and equals)
  • TypeCheck (‘is’) and Cast (‘as’) in Kotlin
  • Kotlin ‘For’ loop
  • [Youtube] Kotlin on Code Quality Tools
  • inline, noinline, crossinline — What do they mean?
  • Qualified ‘this’ in Kotlin
  • Why Kotlin’s Elvis Operator is Better Than Swift’s Guard Statement
  • The hidden Kotlin gem you didn't think you'll love: Deprecations with ReplaceWith
  • Kotlin and Exceptions
  • Reification of the Erased
  • Kotlin’s Noinline & Crossline, once for all
  • Kotlin Functional Interfaces: Function reference and SAM conversion
  • Enhanced Deprecation in Kotlin
  • An opinionated guide on how to make your Kotlin code fun to read and joy to work with
  • Bridging the gap between coroutines, threads, and concurrency problems
  • Express Yourself: An Argument for Ending the Single Letter Generic Type Convention in Kotlin
  • An in-depth look at Kotlin’s initializers
  • The Kotlin modifier that shouldn't be there
  • How to return 2+ values with 0 allocation in Kotlin
  • Avoid unnecessary object creation
  • Use inline modifier for functions with parameters of functional types
  • Consider using inline value classes
  • A Practical Guide to Kotlin's inline Modifier
  • How to leverage functional programming in Kotlin to write better, cleaner code
  • Raising code quality for Faire’s Kotlin codebase
  • Exploring Kotlin initialization with Android custom views
  • Values, not Enums
  • Using the Kotlin standard library from Java
  • Mastering Enums in Kotlin: A Guide to Simplify Your Code
  • [Youtube] TOA: Migrating To kotlin.Result
  • Hide internal members of Kotlin Module from JVM

---

Java

back to top

• Understanding how references work in android and java
• On properly using volatile and synchronized
• Default methods + lambdas = less code
• Try. Finally. If. Not. Null.
• Double-checked locking: Clever, but broken
• Nine Steps of Learning by Refactoring
• Java Annotations tutorial with examples
• Strict Control of Java Code Quality
• Common Bad Programming practices
• Handling Nullability in Your Code
• Java Memory Model

---

Software development

OOP

back to top

• Typical Mistakes in Java Code
• Objects vs. Data Structures
• OOP Alternative to Utility Classes
• Why extends is evil
• Why null is Bad?
• Static methods violate Dependency Inversion principle
• Objects Should Be Immutable
• Solid Is OOP for Dummies
• Getters/Setters. Evil. Period.
• Seven Virtues of a Good Object
• How Immutability Helps
• How Does Inversion of Control Really Work?
• Object Behavior Must Not Be Configurable
• Why Many Return Statements Are a Bad Idea in OOP
• There Can Be Only One Primary Constructor
• Immutable Objects Are Not Dumb
• Constructors Must Be Code-Free
• Class Casting Is a Discriminating Anti-Pattern
• Utility Classes Have Nothing to Do With Functional Programming
• What's Wrong With Object-Oriented Programming?
• If-Then-Else Is a Code Smell
• Inheritance Is a Procedural Technique for Code Reuse
• Gradients of Immutability
• Each Private Static Method Is a Candidate for a New Class
• Inheritance, composition, delegation, and traits
• Builders and Manipulators
• Operator new() is Toxic
• The Perils of Inheritance
• How Data Visibility Hurts Maintainability
• Constructors or Static Factory Methods?
• Streams vs. Decorators
• [Yotube] What's Wrong About Utility Classes?
• [Yotube] Dependency Injection Container is a Bad Idea
• [Yotube] Immutable Objects vs. Common Sense
• [Yotube] A Few Thoughts About Constructors in OOP
• [Yotube] Smart Classes and Functionality-Poor Interfaces
• [Yotube] How Immutability Helps in OOP
• Date/Time Printing Can Be Elegant Too
• [Yotube] The Alternative to Fluent Interfaces in Java
• A Dependency Injector’s 3 Jobs
• [Yotube] Why Static Methods Are Evil?
• Fat vs. Skinny Design
• [Yotube] Naked Data in OOP
• Encapsulate and abstract for future proof software
• The forgotten art of construction
• Immutability we can afford
• [Yotube] How to Inject Less?
• Prestructors
• Distance of coupling
• Compile less with SOLID
• SOLID Principles Sketches
• Smaller Try-Blocks Are Better
• [Youtube] Making Impossible States Impossible

---

Patterns

back to top

• The Evolution Of The Repository Pattern - Be Aware Of Over Abstraction
• Common Design Patterns for Android
• Designing something solid
• Writing Better Adapters
• Dont use DAO, use Repository
• Design Patterns in Android – Observer
• Singletons The Safe Way
• Android Chain Gangs
• Defensive Programming via Validating Decorators
• Vertical and Horizontal Decorating
• Great Adpater Hell Escape
• Building vertical decorators right
• Inversion of control containers and the dependency injection pattern
• Service locator vs dependency injection
• Composable Decorators vs. Imperative Utility Methods
• Bohemian Wrapsody
• A deep dive into the Strategy Design Pattern
• The Builder pattern in Java — yet another Builder Pattern article
• Using the Adapter Design Pattern in Java
• [Youtube] Veil Objects to Replace DTOs
• State Design Pattern
• The Proxy Design Pattern in Java
• Iterator Pattern
• Visitor design pattern
• Facade Design Pattern
• Composite Design Pattern
• Common Design Patterns and App Architectures for Android
• Why service locator is so unpopular
• Streamlining User Actions with the Command Pattern: A Practical Guide

---

Tests

back to top

• Main
  • Should we use mocking libraries for go testing?
  • Clean tests: Naming
  • Clean tests: Comments
  • Testing state vs. testing interaction
  • Test doubles
  • One weird trick to name your tests
  • An Introduction to Testing Custom Views on Android
  • Myths about Unit Tests
  • Three Reasons Why We Should Not Use Inheritance In Our Tests
  • What’s in a name?
  • Unit test vs. Integration test
  • Code coverage
  • Don’t be lazy, use @Rules
  • Mock factory for Android testing in multi-module system
  • Testing on Android using JUnit 5
  • Selectively running Android modularized unit tests on your CI server
  • Parameterized tests with Kotlin’s Sealed Classes
  • Testing Kotlin Lambda Invocations without Mocking
  • Better Kotlin unit testing with mock helper functions
  • Replacing Mocks
  • Unit Testing vs Functional Testing: A Detailed Comparison
  • Code Coverage Best Practices
  • Anti-patterns of automated software testing
  • Unit Tests and Concurrency
  • Mocks, fakes and stubs: the stunt doubles of testing
  • Unit Testing as a 1st-class Citizen
  • Behavior Driven Development (BDD) and Functional Testing
  • Guidelines for writing better tests
  • Should I test private methods directly?
  • Revamping the Android testing pipeline at Dropbox
  • Testing Files without Files
  • Negative Scenarios in Software Testing: Best Practices
  • Unit Testing Delays, Errors & Retries with Kotlin Flows
  • Learning State & Shared Flows with Unit Tests
• Android
  • Fast and reliable UI tests on Android
  • Espresso Test for Intent
  • How to be a mock star
  • Android testing: Unit testing (Part 1)
  • Android testing: Mockito and Robolectric (Part 2)
  • Android testing: Espresso (Part 3)
  • Android testing: UI Automator (Part 4)
  • Dont Use Espresso Idling Resources like Google does
  • Simple way to test asynchronous actions in Android
  • Dagger 2 Testing
  • Why I Don't use Robolectric
  • Junit testing and Android dependencies
  • Unit testing protected lifecycle methods
  • Unit Testable RecyclerViews
  • The 3 tiers of the Android test pyramid
  • Testing Views in Isolation at RoMOBOS
  • Espresso Test Addiction: An Anti-pattern
  • Don’t Keep Activities alone is not enough for testing!
  • Taming UI tests when using multiple Gradle flavors
  • Subclass and override
  • How To Unit Test LiveData and Lifecycle Components
  • Unit testing XML resources
  • Custom view attributes
  • Can you fix the test?
  • Unit Testing in MVVM+Kotlin+DataBinding
  • Isolate your Fragments…just for testing
  • Unit-testing LiveData and other common observability problems
  • Sharing code between local and instrumentation tests
  • Unit Testing RxJava or Coroutine Code With Constructor Injection
  • Kotlin Unit Tests with Parameters
  • Testing Android Architecture Components
  • Android Model-View-Intent with Unit Tests
  • Unit testing on Android
  • Understanding Unit Tests for Android in 2021
  • Troubleshooting Mockito-Kotlin in Android Testing
  • How to mock under instrumentation test with MockK and Dexopener
  • Unit Testing Kotlin Flow
  • Unit Testing RxJava Observables
  • Testing Retrofit calls with OkHttp MockWebServer
  • Why I’m switching from Mockito to Mockk
  • Getting Started with Cucumber
  • Testing Kotlin Coroutines
  • Mocking Matchers API
  • Android BDD with Robolectric and Espresso — how to refactor your Android project tests
  • Unit testing with Mockk tweaks and tricks part1
  • Stubbing with doAnswer vs doReturn – what's the difference?
  • An effective testing strategy for Android
  • WorkManager, Dagger and Testing
  • Testing functions with lambdas using MockK

---

Git

back to top

• Keep a readable Git history
• Four Steps To Maintaining a Clean Git History
• Android Studio and Git Branches – How to Simplify Your Work
• Mastering Git — Why Rebase is amazing
• 8 Productivity Tips for GitHub
• Git from humans to humans — Pull Requests
• Git commands for code detectives
• Merge Git Authors
• Git, beyond version control
• How to never commit a temporary code to your codebase
• Android Kotlin Code Quality Check using Detekt and Git Hooks Pre-push
• [Youtube] Three-branches release model: Master-Candidate-Live
• How to Split Pull Requests – Good Practices, Methods and Git Strategies
• Trello Android's Git Branching Strategy
• How to Pull Request
• How to Prevent Git Commit Naming Mistakes
• Git Rebase For Nested Branches
• Anatomy of a .gitignore

---

Work

back to top

• Main
  • Things You Should Never Do, Part I
  • Perfect code is an illusion
  • The problematic pull request
  • Flexibility Equates to Lower Quality
  • Three Things I Expect From a Software Architect
  • Two Instruments of a Software Architect
  • The Churn
  • Keep Your Features in Progress Out of Your Release Builds
  • Who Is a Project Manager?
  • Either Bugs or Pull Requests ... or You Are Out
  • The TDD That Works for Me
  • Are You an Architect?
  • Don't Aim for Quality, Aim for Speed
  • Who is (not) a Tech Leader
  • Are You a Coder or a Developer?
  • The Formula for Software Quality
  • Programmer’s discipline
  • Five tips to get your code base in shape
  • Achieving Your Goals Feels Good
  • Talk, then code
  • [Youtube] Daily Stand-Up Meetings Are Evil
  • [Youtube] Seven Sins of a Software Project
  • The Big Rewrite
  • [Youtube] Protect yourself against stupid managers—become their good friend!
  • Software Project Review Checklist
  • Is High Quality Software Worth the Cost?
  • Test Driven Development Is Dumb. Fight Me.
  • [Youtube] How to Deal With Conflicts in a Software Team
  • [Youtube] Testing and Quality Assurance (QA) are two entirely different things!
  • Daily Stand-up Injection of Guilt
  • The Joy of Programming
  • TDD Misbeliefs
  • Maybe Don't Write That Test
  • Stakeholder anti-patterns
  • The Problem You Solve Is More Important Than The Code You Write
  • How To Be a Bad Senior Developer
  • How To Use Technical Debt In Your Favor
  • Why so salty? Context is everything in tech discussions.
  • Revolutionary Evolution
  • ‘Must be willing to work under pressure’ is a warning sign
  • “open floor space” is not a job benefit
  • Only code at work? That doesn’t make you a worse programmer
  • Setting boundaries at your job as a programmer
  • A message without a context is unprofessional and very annoying for the listener; don't do it!
  • Talented Programmers, Who Are They?
  • Deadlines
  • Don’t crank out code at 2AM, especially if you’re the CTO
  • 5 Effective Ways to Boost Your Productivity as a Developer
  • Rethinking "Always Be Coding"
  • Intentional qualities
  • To Measure or Not to Measure
  • [Youtube] Micro-management vs. micro-tasking
  • Being a senior software developer
  • Typical programmer’s mistakes
  • How to suck at managing software projects
  • How we scaled technical discussions in the Android team
  • Creating a documentation culture in the Android team
  • Bringing some order to Pull Request reviews
  • 7 Steps to Technical Leadership
  • The Pain of Daily Reports
  • On code style and consistency
  • 3 Inconvenient Truths About Coding
  • What & Why, Not How
  • The 3 Mindsets to Avoid as a Senior Software Developer
  • Great teams merge fast
  • Perks for adult developers
  • 4 Mistakes I Made as a Programmer, but I Had To Become a CTO To See Them
  • How to deal with technical debt
  • Why you need vision and strategy for your team
  • Tech leader self-assessment
  • Senior software engineer, these skills are expected from you
  • An incomplete list of skills senior engineers need, beyond coding
  • Building and Motivating Engineering Teams
  • Stop rewriting projects
  • How to Learn to Code
  • High-Performing Teams Need Psychological Safety. Here’s How to Create It
  • Why Development Teams are Slow
  • Engineering Productivity
  • Lack of Problem Is the Problem
  • What is the Difference Between a Junior and a Senior Developer?
  • Learning a new codebase from its history beyond the code
  • The Pain of Daily Reports
  • [Youtube] Technical leadership and glue work
  • Perfectionism vs. Excellence
  • 10 Mistakes To Avoid as a Software Development Manager
  • [Youtube] The Future of the Testing Role
  • Incident Review and Postmortem Best Practices
  • Building high-performing engineering team
  • [Youtube] Quality Assurance vs. Testing
  • 7 Tips for Becoming a Better Developer
  • What's in a Good Error Message?
  • No, your pull request does not need a review
  • The Hardest Part of Being a Software Manager
  • Self-Managing vs. Manager-Free Organizations
  • Yes, Virginia, You Can Estimate That
  • Imposters to Win!
  • Are you out of alignment?
  • Calibrated Achievement Points
  • Modern software engineering or just a gardener's job!?
  • 5 daily habits of senior engineers
  • How I Use Slack
  • Top 3 Challenges After Becoming an Engineering Manager
  • Dear Manager, You’re Holding Too Many Meetings
  • Code Changes Should Be Small or Mechanical
  • Are meetings making you less productive?
  • 10 Things to do when starting a new job
  • Your Boss Has No Clue
  • [Youtube] 5 Tips for Working On A Team as a Mobile Developer
• Code review
  • Better Code Review
  • The 10 commandments of navigating code reviews
  • Does Code Review Involve Testing?
  • Code Reviews Q&A
  • Code Reviews ?— Good luck with that
• Agile/Scrum/Kanban
  • Scrum and Kanban – Are They That Different After All?
  • What's the Difference? Agile vs Scrum vs Waterfall vs Kanban
  • [Youtube] Agile is Dead
  • Agile is Wrong — Part 1: Scope and Requirements Changes
  • Another View of Agile Software Development
  • What tech leader can learn from direct reports’ performance reviews
  • The mythical 10x programmer
• Feature flags
  • Feature Flags - Why you should care
  • Remote feature flags do not always come for free
  • Feature toggles in trunk based development — Android take

---

Life

back to top

• Main
  • 40 Hours is enough
  • The egoless programmer
  • Is group chat making you sweat?
  • Professional Developer: What Does It Mean?
  • I Don’t Have Time is a Myth
  • I "Love" Anti-patterns
  • Soft Skills Demystified
  • How to Be a Good Office Slave
  • How to Pay Programmers Less
  • How to Be Lazy and Stay Calm
  • Beyond Code; What It Takes to be a Great Software Engineer
  • One Simple Trick to Getting More Free Time
  • What Motivates Me as a Programmer
  • Being Absent While Being Present (don’t do this)
  • How to Cut Corners and Stay Cool
  • The Path to Career Happiness Begins with a Job that Sucks
  • 10 Ways Your Software Career Will Likely Be The Death Of You
  • I am Forky
  • Be Unhappy to Be Happy
  • How Passion for Programming Can Make us Worse at our Jobs
  • What makes a good developer?
  • Work/life balance will make you a better software engineer
  • The not-so-passionate programmer: finding a job when you’re just a normal person
  • Avoiding hour creep: get your work done and still go home at 5PM
  • How to stay motivated
  • Join our startup, we’ll cut your pay by 40%
  • Embrace the Chaos!
  • You are privileged to be a software developer!
  • Ugly Truths About Working From Home
  • Working From Home When You’re Self-Quarantined
  • Hurdles Faced by a Freelancer
  • Working From Home Productivity Tips
  • Don’t Just Code, But Also C…
  • Freelancing
  • Software Developers: Adapt or You’ll Be Replaced
  • What It’s Like Working From Home
  • Gear Up for Remote Work
  • Put a Number on Your Boss's Emotions
  • OPP (Other People’s Problems)
  • [Youtube] Keep a balance between work for money and investments into yourself
  • The Overfinancialization of Everything
  • 23 Life Tasks For Sorting Out Your Life
  • The Happiness Paradox
• Investment
  • The Future of You
  • Time Isn't Money
  • What the Money is For
  • Who Wants to Be a Billionaire?

---

Libraries

Rx

back to top

• Main
  • [Youtube] Introduction to Functional Reactive Programming
  • Unit Testing with RxJava
  • RxJava2: Dispose an Observable chain
  • Concurrency in RxJava 2
  • RxJava — Schedulers — What, when and how to use it?
  • Learning Observable By Building Observable
  • Rx if the operators could speak
  • RxJava as event bus, the right way
  • RxJava & State: The Basics
  • Understanding RxJava Subject — Publish, Replay, Behavior and Async Subject
  • Understanding RxJava subscribeOn and observeOn
  • How we migrated from RxJava1 to RxJava2
  • When you dont need map
  • [Youtube] Common RxJava Mistakes
  • RxJava's repeatWhen and retryWhen, explained
  • RxJava2 puzzle: Scheduler as 3rd parameter
  • RxJava2 puzzle: Subscription threading
  • RxJava2 subscribeOn: How to use it
  • Operators for Transforming Observables
  • How RxJava chain actually works
  • Understanding hot vs cold Observables
• Error
  • Error handling in RxJava
  • The RxJava2 Default Error Handler
  • Error handling in RxJava/RxKotlin
  • Clean architecture — error handling with Kotlin/RxJava
  • Default Error Handling With RxJava
• Backpressure
  • RxJava Backpressure and why should you care?
• Android
  • [Youtube] Exploring RxJava 2 for Android
  • RxJava cheat sheet, with a pinch of Android
  • Retrofit 2 and Rx Java call adapter error handling
  • Server polling and retrying failed operations, with Retrofit and RxJava
  • Overriding RxAndroid Schedulers in RxJava 2
  • LCE: Modeling Data Loading in RxJava
  • MVVM + RxJava: Common Mistakes
  • RxJava2 and Retrofit2 Error Handling on a single place
  • Building an AutoCompleting EditText using RxJava
  • [Youtube] Advanced RxJava and Conductor
  • RxJava on the Sign In Screen
  • How to make complex requests simple with RxJava in Kotlin
  • No Cause for Concern — RxJava and Retrofit Throwing a Tantrum
  • RxJava vs. Coroutines
  • When And How To Use RxJava Disposable
  • RxJava 2: Where’s disposable when subscribe observer?

---

DI

back to top

• Main
  • Android Injection Performance
  • Comparing Three Dependency Injection Solutions
  • About DI Frameworks
• Dagger 2
  • Tasting Dagger 2 on Android
  • Dependency injection with Dagger 2 - Custom scopes
  • [Yotube] DAGGER 2 - A New Type of dependency injection
  • [Yotube] The Future of Dependency Injection with Dagger 2
  • A Dagger to Remember
  • Clean Android Application class with Dependency Injection: AppInitializers
  • Keeping the Daggers Sharp
  • Abusing Dagger with Initializers
  • Dagger in Kotlin: Gotchas and Optimizations
  • Dagger 2, 2 Years Later
  • From Dagger components to manual dependency injection
  • Dagger dependencies beyond the basics
  • Injection into Android Component’s Constructors is real
  • Facilitating dependency initialization with Dagger multibindings
  • Dagger Tips: Leveraging AssistedInjection to inject ViewModels
  • How to Optimize Dagger Module
  • Dagger & Kotlin
• Koin
  • [Youtube] Arnaud Giuliani - Dependency injection from zero to hero with Koin
• Hilt
  • Exploring dagger hilt: an introduction
  • Dependency Injection on Android with Hilt
  • Create an application CoroutineScope using Hilt
  • Scoping in Android and Hilt
  • Migrating from Dagger to Hilt — Is it worth it?
  • Hilt — Adding components to the hierarchy

---

Net

back to top

• Advanced Retrofit
• Configuring Retrofit 2 Client in Android
• OkHttp & OAuth: Token Refreshes
• Maximizing OkHttp connection reuse
• Retrofit — Effective error handling with Kotlin Coroutine and Result API

---

Other Libraries

back to top

• Introducing Ruler: Our Tool for Measuring Android App Size