Exception handling in Kotlin Coroutines
Everything you need to know about exception handling mechanism in Kotlin Coroutines.
Item 52: Consider associating elements to a map
How is associateBy useful to improve the performance of finding elements.
Cancellation in Kotlin Coroutines
Everything you need to know about cancellation mechanism in Kotlin Coroutines.
Item 51: Prefer Sequence for big collections with more than one processing step
What is the difference between list and sequence processing, and when each should be preferred.
Job and children awaiting in Kotlin coroutines
What is Job and how it is this most important context responsible for structured concurrency.
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 is the difference between the coroutine functionalities build into language, and those distributed as a library.
Effective Kotlin Item 49: Consider using inline value classes
What are value classes, 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 for performance optimization.
Coroutine builders
How do we start coroutines, what is structured concurrency and how does it work?
Sequence builders in Kotlin Coroutines
How sequences can be created using Kotlin coroutines.
Effective Kotlin Item 35: Consider defining a DSL for complex object creation
What are Kotlin DSLs, how do they work, and how can we implement this pattern ourselves.
Traits for testing in Kotlin
A trick needed when using traits for testing in Kotlin.
Why using Kotlin Coroutines?
The explanation, 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 are member extensions, how they are possible and why we should avoid using them.
Kotlin Coroutines dispatchers
Where should we use each dispatcher from the Kotlin coroutines library
Effective Kotlin Item 45: Consider extracting non-essential parts of your API into extensions
What are the differences between members and extensions, and in what cases we should prefer one over another.
Effective Kotlin Item 44: Respect the contract of compareTo
What the contract of the compareTo is and why we should care.
Effective Kotlin Item 43: Respect the contract of hashCode
What the contract of the hashCode is and why we should care.
Effective Kotlin Item 42: Respect the contract of equals
What the contract of the equals is and why we should care.
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 40: Prefer class hierarchies to tagged classes
What tagged classes are and why we should use class hierarchies instead of them.
Effective Kotlin Item 39: Use sealed classes and interfaces to express restricted hierarchies
Sealed classes and interfaces might not look like a big deal, but they changed a lot in the way we structure programs.
Effective Kotlin Item 38: Use function types or functional interfaces to pass operations and actions
Kotlin introduced support for function types and function interfaces, and they should be used to represent operations and actions as objects.
Effective Kotlin Item 37: Use the data modifier to represent a bundle of data
Data modifier is a powerful tool. Let's learn about how it works, what are its perils and dangers.
Effective Kotlin Item 36: Prefer composition over inheritance
Years of OOP made us overuse inheritance. Instead, we should more often use composition, that is safer and more explicit. More often, but not always...
