Kt. Academy

Advent of Kotlin: Week 1

Week 1 of the Advent of Kotlin

Marcin Moskała
12/1/2021

Effective Kotlin Extra Item: Use operators to increase readability

How to use operators to improve readability in Kotlin.

Marcin Moskała
11/22/2021

Variables point to objects

A basic feature, that is commonly misunderstood.

Marcin Moskała
11/17/2021

Hot and cold data sources

What is the difference between hot data sources (like list or channel) and cold ones (like sequence or flow)?

Marcin Moskała
11/17/2021

Effective Kotlin Item 56: Consider using mutable collections

When mutable collections are preferred over immutable ones.

Marcin Moskała
11/8/2021

Channel in Kotlin Coroutines

What a channel is, how it works, and where we can use it.

Marcin Moskała
11/3/2021

Testing Kotlin Coroutines

How we test Kotlin Coroutines, including common Android and backend cases.

Marcin Moskała
10/27/2021

Effective Kotlin Item 55: Consider Arrays with primitives for performance-critical processing

What is the difference between using collections and arrays of primitives?

Marcin Moskała
10/25/2021

Coroutines answer to the problem with the mutable state

What thread-safety mechanisms we should use in Kotlin Coroutines.

Marcin Moskała
10/20/2021

Constructing coroutine scope

How we generally define coroutine scope on Android and on the backend.

Marcin Moskała
10/13/2021

Effective Kotlin Item 53: Consider using groupingBy instead of groupBy

What Grouping is, and how groupingBy instead of groupBy can be a performance optimization.

Marcin Moskała
10/11/2021

Coroutine scope functions

How coroutineScope, withContext and other scoping function work, and why it is great.

Marcin Moskała
10/6/2021

Exception handling in Kotlin Coroutines

Everything you need to know about the exception handling mechanism in Kotlin Coroutines.

Marcin Moskała
9/29/2021

Effective Kotlin Item 52: Consider associating elements to a map

How associateBy is useful to improve the performance of finding elements.

Marcin Moskała
9/27/2021

Cancellation in Kotlin Coroutines

Everything you need to know about the cancellation mechanism in Kotlin Coroutines.

Marcin Moskała
9/22/2021

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.

Marcin Moskała
9/20/2021

Job and children awaiting in Kotlin Coroutines

What Job is and how it is the most important context responsible for structured concurrency.

Marcin Moskała
9/15/2021

Effective Kotlin Item 50: Eliminate obsolete object references

How to help our garbage collector and avoid memory leaks.

Marcin Moskała
9/13/2021

Coroutines built-in support vs library

What the difference is between the coroutine functionalities build into language, and those distributed as a library.

Marcin Moskała
9/8/2021

Effective Kotlin Item 49: Consider using inline value classes

What value classes are, how to use and inline them.

Marcin Moskała
9/6/2021

Coroutines under the hood

A deep dive into how suspension and continuations work under the hood.

Marcin Moskała
9/1/2021

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.

Marcin Moskała
8/30/2021

What is CoroutineContext and how does it work?

A deep explanation of the coroutine context - the powerful data holder for coroutines.

Marcin Moskała
8/25/2021

Effective Kotlin Item 47: Avoid unnecessary object creation

About the most essential rule of performance optimization.

Marcin Moskała
8/22/2021

Coroutine builders

How do we start coroutines, what is structured concurrency and how does it work?

Marcin Moskała
8/18/2021

Sequence builders in Kotlin Coroutines

How sequences can be created using Kotlin Coroutines.

Marcin Moskała
8/11/2021

Effective Kotlin Item 35: Consider defining a DSL for complex object creation

What Kotlin DSLs are, how they work, and how we can implement this pattern ourselves.

Marcin Moskała
8/8/2021

Traits for testing in Kotlin

A trick needed when using traits for testing in Kotlin.

Marcin Moskała
8/6/2021

Why using Kotlin Coroutines?

The explanation of why coroutines stand out and offer us what hasn't been offered by other technologies.

Marcin Moskała
8/4/2021

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.

Marcin Moskała
8/1/2021

How does suspension work in Kotlin coroutines?

A deep explanation of how suspension works in Kotlin Coroutines.

Marcin Moskała
7/28/2021

Effective Kotlin Item 33: Consider factory functions instead of constructors

What factory functions are and why they are so important patterns for object creation.

Marcin Moskała
7/25/2021

Effective Kotlin Item 46: Avoid member extensions

What member extensions are, how they are possible and why we should avoid using them.

Marcin Moskała
7/18/2021

Kotlin Coroutines dispatchers

Where we should use each dispatcher from the Kotlin Coroutines library.

Marcin Moskała
7/14/2021

Effective Kotlin Item 45: Consider extracting non-essential parts of your API into extensions

What the differences between members and extensions are, and in what cases we should prefer one over another.

Marcin Moskała
7/11/2021

Effective Kotlin Item 44: Respect the contract of compareTo

What the contract of the compareTo is and why we should care.

Marcin Moskała
7/4/2021

Effective Kotlin Item 43: Respect the contract of hashCode

What the contract of the hashCode is and why we should care.

Marcin Moskała
6/27/2021

Effective Kotlin Item 42: Respect the contract of equals

What the contract of the equals is and why we should care.

Marcin Moskała
6/20/2021

Kt. Academy new logo: Phoenix

Why we decided to change our logo, and what is the symbolism of Phoenix.

Marcin Moskała
6/16/2021

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?

Marcin Moskała
6/13/2021

Effective Kotlin Item 40: Prefer class hierarchies to tagged classes

What tagged classes are and why we should use class hierarchies instead of them.

Marcin Moskała
6/6/2021

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.

Marcin Moskała
5/30/2021

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.

Marcin Moskała
5/23/2021

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 and what its perils and dangers are.

Marcin Moskała
5/8/2021

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...

Marcin Moskała
4/25/2021

More articles on Medium