Kt. Academy Logo
WorkshopsCoursesBooksArticles

Kt. Academy Blog

Understanding Flow

We will explore how flow and its processing really works.

Introduction to the Flow

What is Flow and how it is supposed to be used.

The second edition of Kotlin Coroutines: Deep Dive book is finally ready!

Learn about the new release of the famous book about Kotlin Coroutines.

Select in Kotlin Coroutines

What is and how to use select function in Kotlin coroutines.

Why you should consider migrating your Gradle scripts to Kotlin DSL

Discover the benefits of migrating your Gradle scripts to Kotlin DSL and streamline your development process.

Map as a property delegate

How do we use Map as a property delegate, and why the result of a famous puzzler should not be surprising.

Observable and Vetoable delegates

What are observable and vetoable delegates, and what are their real-life use cases.

Best practices

Let's review the Kotlin Coroutines best practices.

Kotlin revolutionary announcement

Kotlin announcement that will change the way we all will write code.

Using coroutines from other languages

How to interoperate between Kotlin Coroutines and other languages.

Kotlin Coroutines Recipes

Let's see some recipes useful in Kotlin Coroutines projects.

Testing flow

Learn the most important tools and practices for testing Kotlin Flow.

Lazy property delegate

What is lazy delegate, and what are its real-life use cases.

Property delegation

What is property delegation, how does it work, and how can we implement our custom property delegate.

Nullability in Kotlin

How Kotlin null-safety works, and how can we deal with nullable values.

Interface Delegation

One of the least known Kotlin features, that can be sometimes found really useful.

Kotlin bites on Twitter 2

A collection of Kotlin bites of knowledge, in a form of tweets.

Basic values in Kotlin

Learn about the basic Kotlin values, types and operations.

Variance modifiers limitations

What limitations generic variance modifiers introduce, and how can we ignore them.

Covariant Nothing Object

The pattern we are all using, but no-one talks about it.

Kotlin Generic Variance Modifiers

What are out and in, and how do we use them without even knowing.

Enum classes in Kotlin

What are enum classes in Kotlin and how do we use them.

Operator overloading in Kotlin

How are operators defined for types in Kotlin, and how can we define our own operators.

The power of Kotlin for-loop

Learn about the amazing capabilities of Kotlin for-loop.

Kotlin bites on Twitter 1

A collection of Kotlin bites of knowledge, in a form of tweets.

Your first program in Kotlin

How to write your first program, how can we use it in real-life projects, and how to explore what Kotlin is compiled to.

Running Kotlin coroutines on Project Loom's virtual threads

How to use Project Loom to improve Coroutines performance.

A birds-eye view of Arrow: Data Immutability with Arrow Optics

Learn to use Arrow Optics to support working on immutable objects.

Kotlin Essentials book is finally ready!

Learn about our recently published book dedicated to the essential Kotlin features.

Marcin Moskała
Marcin Moskała12/16/2022

Launching coroutines vs suspend functions

The two most important kinds of functions in Kotlin Coroutines, and how should we use them.

Marcin Moskała
Marcin Moskała12/13/2022

Functions in Kotlin

Learn about what functions can offer us in Kotlin.

Marcin Moskała
Marcin Moskała12/12/2022

Slowing down your code with Coroutines

How can we use coroutines to slow down our code, and why would we want to do that.

Kotlin Coroutines use cases introduction

Introducing a series of articles about common Kotlin Coroutines use cases.

A birds-eye view of Arrow: Error Handling

Learn about Error Handling in Arrow, end how to effectively work with Either.

Kotlin Coroutines use cases for Presentation/API/UI Layer

How do we use Kotlin Coroutines in the Presentation/API/UI Layer Layer, how do we create scope and start coroutines.

Marcin Moskała
Marcin Moskała11/30/2022

Generics in Kotlin

The essence of how generics work in Kotlin.

Marcin Moskała
Marcin Moskała11/29/2022

A birds-eye view of Arrow: working with function with Arrow Core

Learn about essential Arrow functions used for composition, memoization, recursion and functions generation.

Kotlin Coroutines use cases for Domain Layer

How do we use Kotlin Coroutines in the Domain Layer.

Marcin Moskała
Marcin Moskała11/24/2022

Kotlin Coroutines use cases for Data/Adapters Layer

How do we use Kotlin Coroutines in the Data/Adapters Layer, how do we use callback or blocking functions.

Marcin Moskała
Marcin Moskała11/15/2022

Item 16: Properties should represent state, not behavior

What should be defined as a behavior, and what should rather be a function.

Functional Kotlin book is finally ready!

Learn about our recently published book dedicated to functional Kotlin features.

Item 12: An operator’s meaning should be consistent with its function name

When is it fine to override operators, and when it is not.

Marcin Moskała
Marcin Moskała10/31/2022

Item 11: Design for readability

Do we really want out applications concise, or do we rather want them readable?

Marcin Moskała
Marcin Moskała10/24/2022

Item 7: Prefer a nullable or Result result type when the lack of a result is possible

Why should we prefer to avoid throwing exceptions and using types to our advantage.

Marcin Moskała
Marcin Moskała10/19/2022

Item 5: Specify your expectations for arguments and state

How do we specify requirements and expectations in Kotlin.

Marcin Moskała
Marcin Moskała10/12/2022

Context receivers

All you need to know about the new and powerful Kotlin feature: context receivers.

Item 3: Eliminate platform types as soon as possible

Why platform types are so dangerous, and how should we deal with them.

Item 1: Limit mutability

Why it is so important to limit mutability, and how Kotlin supports it.

Scope functions

What is let, also, apply and with, and how to use them in our applications.

Type modelling in Kotlin

Type safety is undervalued in most software projects and causes enormous financial losses throughout the world. Changing a few bad habits can lead to more reliable software.

DSL type-safe builders

How to define type-safe DSL builders in Kotlin.

Lambda expressions

Let's learn how to use lambda expressions, what special support they have, and what traps they generate.

Object-oriented or functional? Two ways to see the world

The difference between the OOP and FP paradigms is deeply rooted in how we see the world. A few words on the philosophy of both approaches.

Essential programming nomenclature

Find out what you need to know, before you start writing documentations, books or articles about programming.

Function references

How do we reference functions in Kotlin, to replace lambda expressions. All functions, including constructors, getters, extensions and more.

Best Principles for Successful Test Automation (API and UI)

Aligning our testing activities with ISTQB standards helps us to perform efficiently and cope with project scope and deadlines. In this workshop we will go over software testing stages starting from definition to maintenance.

Mesut Durukal
Mesut Durukal6/14/2022

Leveraging AI in Software Testing

As AI is confronting us in our daily lives and it is improving the development activities by eliminating some manual efforts, it is beneficial to embrace in our tasks. We will see how we can utilize AI based algorithms in Software Testing.

Software Testing Standards (Aligned with ISTQB)

Aligning our testing activities with ISTQB standards helps us to perform efficiently and cope with project scope and deadlines. In this workshop we will go over software testing stages starting from definition to maintenance.

Mesut Durukal
Mesut Durukal5/31/2022

How to write a technical book?

A guide for writing technical books.

Persistent memory design choices and use-cases

Let's understand some design choices with persistent memory and use-cases of persistent memory.

Why is Kotlin your next Programming Language?

What is Kotlin, and why it should be your next programming language.

Persistent dictionary

Let's make our in-memory dictionary persistent and understand some concepts of PMDK.

Code or No-code?

What are the strong sides of code and no-code, and why do they constantly fight with each other.

Introducing persistent memory

Let's learn the basics of persistent memory, its characteristics, how it works and the beauty of byte addressability.

In-memory dictionary

Let's begin our journey to understand persistent memory by building an in-memory dictionary.

Persistent memory - Introduction

Do you want to learn about persistent memory? Join this journey to explore persistent memory and build a persistent dictionary.

Funny programming comics

A collection of funny comics for programmers.

Kotlin Coroutines: Deep Dive book is finally ready!

Learn about our recently published book dedicated to Kotlin Coroutines.

SharedFlow and StateFlow

Known as a replacement for Subject, LiveData, and many more. SharedFlow and StateFlow are powerful coroutines classes, every Kotlin developer should know.

Flattening flow: flatMapConcat, flatMapMerge and flatMapLatest

Let's learn how can we flatMap flow with flatMapConcat, flatMapMerge, and flatMapLatest.

Collecting values on flow: fold and scan

Let's learn how can we accumulate flow values with fold and scan.

Funny programming videos

A collection of funny videos for programmers.

Combining flows: merge, zip, and combine

Let's learn how can we transform two flows into one, with merge, zip, and combine.

Flow lifecycle operations

Let's learn about lifecycle operations, controlling context, and handling exceptions in flow.

Flow building

Every flow needs to start somewhere, so let's 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

Marcin Moskała
Marcin Moskała12/21/2021

Advent of Kotlin: Week 3

Week 3 of the Advent of Kotlin: k-means clustering

Marcin Moskała
Marcin Moskała12/14/2021

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

Item 13: Use operators to increase readability

How to use operators to improve readability in Kotlin.

Marcin Moskała
Marcin Moskała11/22/2021

Variables point to objects

A basic feature, that is commonly misunderstood.

Marcin Moskała
Marcin Moskała11/17/2021

Testing Kotlin Coroutines

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

Marcin Moskała
Marcin Moskała10/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
Marcin Moskała10/25/2021

Constructing a coroutine scope

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

Marcin Moskała
Marcin Moskała10/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
Marcin Moskała10/11/2021

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.

Coroutine builders

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 secondary 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 Medium