Manually curated collection of links about android development, developer work and life, that I found useful/interesting.
Jump to
- 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
- Translucent SystemBars the right way — across API levels and themes
- 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
- 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
- Using PreviewParameters and providing Composables to Jetpack Compose Previews
- Deep-dive into derivedStateOf and comparison with remember(key)
- Custom TabRow Indicator in Jetpack Compose
- Text Scrolling in Jetpack Compose
- Designing Jetpack Compose architecture for a gradual transition from fragments
- Understanding re-composition in Jetpack Compose with a case study
- Touch Feedback Animation like Spotify in Jetpack Compose
- Encapsulate your @Composable functions
- Problem solving in Compose Text
- Jetpack Compose Tricks: Conditionally Applying Modifiers for Dynamic UIs
- Compose a Compose Button by composing Composable functions
- Solving the mystery of recompositions in Compose's LazyList
- Reduce Recomposition for Images/Icons In Jetpack Compose
- Jetpack Compose Side Effects in Details
- Better Previews in Jetpack Compose, Tips and Tricks
- Jetpack Compose with ViewModel and Flow: A Comprehensive Guide
- Exploring Lazy Staggered Grids in Jetpack Compose
- Jetpack Compose: Passing data implicitly in Composable screens
- Jetpack Compose Popup — Master It!
- Refining Compose API for design systems
- Optimizing Jetpack Compose with @Stable: Smart Recomposition Strategies
- @Composable Modifier vs composed factory in Jetpack Compose
- Stop Passing Event/UI-Action Callbacks in Jetpack Compose
- 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
- 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
- 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
- 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 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
- Using Version Catalog on Android projects
- Android Security: Securing your Gradle builds from baddies
- State of Dependency Management in Android Studio
- 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
- Android ViewModel: Single state or not?
- 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
- Problems With Navigation in Jetpack Compose
- String
- 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
- 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
- Injection Points
- Modelling the domain layer using composable use cases
- Guide to Android app modularization
- Modern Android Development in 2023
- How to Implement MVI with Delegates on Android
- 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
- Android Studio — Hide generated files from search results
- 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
- Background restrictions in Android
- 6 Types of Encryption That You Must Know About
- Text Will Not Always Scale
- Not All ViewBinding Need Null Setting
- Net
- 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
- Keep Rules in the Age of Kotlin
- APK/Multidex
- Memory leak
- 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
- Introducing Konsist: A Cutting-Edge Kotlin Linter
- Room
- 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
- 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
- A Perception of Exception in Kotlin Coroutines
- Callback to Coroutines in Kotlin
- 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
- Patterns
- Variable
- 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
- State production with unidirectional data flow and Kotlin Flows
- 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
- Error Handling the Kotlin Way
- 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
- We don’t need Java anymore – it belongs to a different era
- 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
- 👨💻Kotlin SOLID Principles
- 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
- Dependency Injection vs. Service Locator
- 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
- Confirmed: Code Coverage Is a Useless Management Metric
- Prefer Integration Tests Over Unit Tests
- Test My Code, Not My Limits
- 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
- The conflation problem of testing StateFlows
- [Youtube] Solution to Share Code Between Tests in Android!
- 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
- 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
- The Best Advice I Have Ever Been Given
- Farm or Grind
- Modern work requires attention. Constant alerts steal it
- The hardest part of building software is not coding, it’s requirements
- From Teammate to Team Lead – A Balancing Act
- Managing Complex Change
- 4 Engineering Slides CEOs Love (That You Can Have For Free)
- 7 Signals That You Aren’t a Competent Senior Developer (Yet)
- The Five Things Software Engineers Hate About Their Jobs
- How Programmers Can Spot a Bad Company
- The 7 Most Stressful Things About Working In An Office
- 5 Clues That You’re in a Toxic Software Dev Company
- My Friend Quit a $160k Job Because It Was a “Developer’s Trap”
- Why does Software Engineering take so long?
- Good Manager / Bad Manager
- How to Spot Shitty Software Engineer Job Postings
- Why Good Engineers Leave Good Companies
- The 7 Signs of a Bad Programmer
- 10 Signs of Toxicity in Teams You Shouldn’t Ignore
- Measuring Technical Debt to Avoid the Boiling Frog Syndrome
- CTO vs. VP of Engineering: Defining Technical Titles
- Remote Work Isn’t Dead – An Inevitable Uprising is Brewing
- Software engineering: problem-solving and critical-thinking
- Why Job Hops Don’t Harm Experienced Developers
- The True Cost of Technical Debt
- How Engineers Can Identify Good (and Avoid Bad) Companies
- Why Do Developers Quit Their Jobs?
- Too Many Meetings Is Not Your Problem
- I Needed to Rewire My Brain at the First Year at Big Tech
- Why so many software engineers are that bad?
- How to hedge against layoffs
- What is broken with hiring in tech?
- 15 Reasons Why People Should Change Jobs (but rarely do)
- Experienced Developers, Don’t Believe These 5 Deadline Myths to Become More Effective
- Useless Features Are The Biggest Bugs
- Here’s what I do all day as a staff engineer
- The “Left Hand, Right Hand” Problem Of Most Organizations
- 5 Causes of Underperforming Teams
- Why Do Big Companies Ask Unrealistic Software Engineering Interview Questions?
- The #1 Skill Every Developer Needs (And It’s Not Coding)
- 5 Habits Overperforming Developers Should Drop if They Want to Be Better Teammates
- What’s Right Is Not Always Right for You
- Asking for Estimates: The Telltale Sign of Ineffective Software Development Practices
- Code review
- 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
- “Sprints”: The biggest mistake of Software Engineering
- Agile Teams Require Socially Skilled Developers
- Dear Scrum, It’s Not Me, It’s You
- Feature flags
- 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
- Don't expect to be motivated everyday
- A 40+ Years Experienced Software Architect Advised Me How Not to Be Burned out as a Developer
- Dear Devs… Listen to Bill Gate’s “There’s More to Life Than Work”
- Lay offs are a reminder to NOT prioritize your work (The Fatal Mistake Devs make)
- Make Every Second Count: Strategies to Unleash Creativity and Success at Any Time
- Open Source Is Struggling And It’s Not Big Tech That Is To Blame
- Feeling Overwhelmed? You Need an MVD—That’s Minimum Viable Day
- The Daily Battle for Brain Space
- Executives Are Now “Cranky” About An Employee “Dead Zone”
- 5 Strategies to Help You Survive the Last Years Before Leaving The Rat Race
- Why and How to Be a High Performer Even if You Don’t Like Your Job
- What You Need to Realize When You Turn 35 as a Programmer
- 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
- Backpressure
- 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?
- Main
- 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
- Hilt
- 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