Every flow needs to start somewhere, so let'a explore all the different flow builders.
Advent of Kotlin Solutions
Solutions to the Advent of Kotlin!
Advent of Kotlin: Week 4
Week 4 of the Advent of Kotlin: Parsing JSON
Advent of Kotlin: Week 3
Week 3 of the Advent of Kotlin: k-means clustering
Advent of Kotlin: Week 2
Week 2 of the Advent of Kotlin: Tree algorithms
Advent of Kotlin: Week 1: JSON stringify and possible value parentheses
Week 1 of the Advent of Kotlin: JSON stringify and possible well-formed parentheses
Effective Kotlin Extra Item: Use operators to increase readability
How to use operators to improve readability in Kotlin.
Variables point to objects
A basic feature, that is commonly misunderstood.
Testing Kotlin Coroutines
How we test Kotlin Coroutines, including common Android and backend cases.
Effective Kotlin Item 55: Consider Arrays with primitives for performance-critical processing
What is the difference between using collections and arrays of primitives?
Constructing a coroutine scope
How we generally define coroutine scope on Android and on the backend.
Effective Kotlin Item 53: Consider using groupingBy instead of groupBy
What Grouping is, and how groupingBy instead of groupBy can be a performance optimization.
Coroutine scope functions
How coroutineScope, withContext and other scoping function work, and why it is great.
Exception handling in Kotlin Coroutines
Everything you need to know about the exception handling mechanism in Kotlin Coroutines.
Effective Kotlin Item 52: Consider associating elements to a map
How associateBy is useful to improve the performance of finding elements.
Cancellation in Kotlin Coroutines
Everything you need to know about the cancellation mechanism in Kotlin Coroutines.
Effective Kotlin Item 51: Prefer Sequence for big collections with more than one processing step
What the difference between list and sequence processing is, and when each should be preferred.
Effective Kotlin Item 50: Eliminate obsolete object references
How to help our garbage collector and avoid memory leaks.
Coroutines built-in support vs library
What the difference is between the coroutine functionalities build into language, and those distributed as a library.
Effective Kotlin Item 49: Consider using inline value classes
What value classes are, how to use and inline them.
Coroutines under the hood
A deep dive into how suspension and continuations work under the hood.
Effective Kotlin Item 48: Use inline modifier for functions with parameters of functional types
How inline functions work and why they can be so important for the performance of our application.
What is CoroutineContext and how does it work?
A deep explanation of the coroutine context - the powerful data holder for coroutines.
Effective Kotlin Item 47: Avoid unnecessary object creation
About the most essential rule of performance optimization.
How do we start coroutines, what is structured concurrency and how does it work?
Traits for testing in Kotlin
A trick needed when using traits for testing in Kotlin.
Why using Kotlin Coroutines?
The explanation of why coroutines stand out and offer us what hasn't been offered by other technologies.
Effective Kotlin Item 34: Consider a primary constructor with named optional arguments
Why telescoping-constructor pattern and the classic builder pattern are considered outdated in Kotlin.
How does suspension work in Kotlin coroutines?
A deep explanation of how suspension works in Kotlin Coroutines.
Effective Kotlin Item 33: Consider factory functions instead of constructors
What factory functions are and why they are so important patterns for object creation.
Effective Kotlin Item 46: Avoid member extensions
What member extensions are, how they are possible and why we should avoid using them.
Kotlin Coroutines dispatchers
Where we should use each dispatcher from the Kotlin Coroutines library.
Kt. Academy new logo: Phoenix
Why we decided to change our logo, and what is the symbolism of Phoenix.
Effective Kotlin Item 41: Use enum to represent a list of values
When should we use enum classes, and when sealed classes instead? What are the advantages of both approaches?
Effective Kotlin Item 36: Prefer composition over inheritance
Years of OOP made us overuse inheritance. Instead, we should more often use a composition that is safer and more explicit. More often, but not always...
More articles on