Workshops
Courses
Books
Articles
Kt. Academy Blog
Understanding Flow
We will explore how flow and its processing really works.
Marcin Moskała
5/29/2023
Introduction to the Flow
What is Flow and how it is supposed to be used.
Marcin Moskała
5/22/2023
The second edition of Kotlin Coroutines: Deep Dive book is finally ready!
Learn about the new release of the famous book about Kotlin Coroutines.
Marcin Moskała
5/16/2023
Select in Kotlin Coroutines
What is and how to use select function in Kotlin coroutines.
Marcin Moskała
5/15/2023
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.
Nirav Tukadiya
5/10/2023
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.
Marcin Moskała
5/8/2023
Observable and Vetoable delegates
What are observable and vetoable delegates, and what are their real-life use cases.
Marcin Moskała
5/2/2023
Best practices
Let's review the Kotlin Coroutines best practices.
Marcin Moskała
4/24/2023
Kotlin revolutionary announcement
Kotlin announcement that will change the way we all will write code.
Marcin Moskała
4/19/2023
Using coroutines from other languages
How to interoperate between Kotlin Coroutines and other languages.
Marcin Moskała
4/17/2023
Kotlin Coroutines Recipes
Let's see some recipes useful in Kotlin Coroutines projects.
Marcin Moskała
4/11/2023
Testing flow
Learn the most important tools and practices for testing Kotlin Flow.
Marcin Moskała
4/3/2023
Lazy property delegate
What is lazy delegate, and what are its real-life use cases.
Marcin Moskała
3/27/2023
Property delegation
What is property delegation, how does it work, and how can we implement our custom property delegate.
Marcin Moskała
3/20/2023
Nullability in Kotlin
How Kotlin null-safety works, and how can we deal with nullable values.
Marcin Moskała
3/13/2023
Interface Delegation
One of the least known Kotlin features, that can be sometimes found really useful.
Marcin Moskała
3/6/2023
Kotlin bites on Twitter 2
A collection of Kotlin bites of knowledge, in a form of tweets.
Marcin Moskała
3/1/2023
Basic values in Kotlin
Learn about the basic Kotlin values, types and operations.
Marcin Moskała
2/27/2023
Variance modifiers limitations
What limitations generic variance modifiers introduce, and how can we ignore them.
Marcin Moskała
2/20/2023
Covariant Nothing Object
The pattern we are all using, but no-one talks about it.
Marcin Moskała
2/13/2023
Kotlin Generic Variance Modifiers
What are out and in, and how do we use them without even knowing.
Marcin Moskała
2/8/2023
Enum classes in Kotlin
What are enum classes in Kotlin and how do we use them.
Marcin Moskała
2/1/2023
Operator overloading in Kotlin
How are operators defined for types in Kotlin, and how can we define our own operators.
Marcin Moskała
1/23/2023
The power of Kotlin for-loop
Learn about the amazing capabilities of Kotlin for-loop.
Marcin Moskała
1/18/2023
Kotlin bites on Twitter 1
A collection of Kotlin bites of knowledge, in a form of tweets.
Marcin Moskała
1/12/2023
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.
Marcin Moskała
1/10/2023
Running Kotlin coroutines on Project Loom's virtual threads
How to use Project Loom to improve Coroutines performance.
Jan Vladimir Mostert
1/9/2023
A birds-eye view of Arrow: Data Immutability with Arrow Optics
Learn to use Arrow Optics to support working on immutable objects.
Alejandro Serrano Mena
12/19/2022
Kotlin Essentials book is finally ready!
Learn about our recently published book dedicated to the essential Kotlin features.
Marcin Moskała
12/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
12/13/2022
Functions in Kotlin
Learn about what functions can offer us in Kotlin.
Marcin Moskała
12/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.
Jan Vladimir Mostert
12/9/2022
Kotlin Coroutines use cases introduction
Introducing a series of articles about common Kotlin Coroutines use cases.
Marcin Moskała
12/7/2022
A birds-eye view of Arrow: Error Handling
Learn about Error Handling in Arrow, end how to effectively work with Either.
Simon Vergauwen
12/6/2022
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
11/30/2022
Generics in Kotlin
The essence of how generics work in Kotlin.
Marcin Moskała
11/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.
Alejandro Serrano Mena
11/28/2022
Kotlin Coroutines use cases for Domain Layer
How do we use Kotlin Coroutines in the Domain Layer.
Marcin Moskała
11/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
11/15/2022
Item 16: Properties should represent state, not behavior
What should be defined as a behavior, and what should rather be a function.
Marcin Moskała
11/9/2022
Functional Kotlin book is finally ready!
Learn about our recently published book dedicated to functional Kotlin features.
Marcin Moskała
11/7/2022
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
10/31/2022
Item 11: Design for readability
Do we really want out applications concise, or do we rather want them readable?
Marcin Moskała
10/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
10/19/2022
Item 5: Specify your expectations for arguments and state
How do we specify requirements and expectations in Kotlin.
Marcin Moskała
10/12/2022
Context receivers
All you need to know about the new and powerful Kotlin feature: context receivers.
Marcin Moskała
10/7/2022
Item 3: Eliminate platform types as soon as possible
Why platform types are so dangerous, and how should we deal with them.
Marcin Moskała
10/5/2022
Item 1: Limit mutability
Why it is so important to limit mutability, and how Kotlin supports it.
Marcin Moskała
9/28/2022
Scope functions
What is let, also, apply and with, and how to use them in our applications.
Marcin Moskała
9/23/2022
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.
Jan Vladimir Mostert
9/14/2022
DSL type-safe builders
How to define type-safe DSL builders in Kotlin.
Marcin Moskała
9/9/2022
Lambda expressions
Let's learn how to use lambda expressions, what special support they have, and what traps they generate.
Marcin Moskała
8/26/2022
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.
Marcin Moskała
8/18/2022
Essential programming nomenclature
Find out what you need to know, before you start writing documentations, books or articles about programming.
Marcin Moskała
8/11/2022
Function references
How do we reference functions in Kotlin, to replace lambda expressions. All functions, including constructors, getters, extensions and more.
Marcin Moskała
7/29/2022
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
6/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.
Mesut Durukal
6/7/2022
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
5/31/2022
How to write a technical book?
A guide for writing technical books.
Marcin Moskała
5/27/2022
Persistent memory design choices and use-cases
Let's understand some design choices with persistent memory and use-cases of persistent memory.
Sarthak Makhija
5/26/2022
Why is Kotlin your next Programming Language?
What is Kotlin, and why it should be your next programming language.
Albert McQuiston
5/24/2022
Persistent dictionary
Let's make our in-memory dictionary persistent and understand some concepts of PMDK.
Sarthak Makhija
5/19/2022
Code or No-code?
What are the strong sides of code and no-code, and why do they constantly fight with each other.
Marcin Moskała
5/17/2022
Introducing persistent memory
Let's learn the basics of persistent memory, its characteristics, how it works and the beauty of byte addressability.
Sarthak Makhija
5/12/2022
In-memory dictionary
Let's begin our journey to understand persistent memory by building an in-memory dictionary.
Sarthak Makhija
5/5/2022
Persistent memory - Introduction
Do you want to learn about persistent memory? Join this journey to explore persistent memory and build a persistent dictionary.
Sarthak Makhija
4/28/2022
Funny programming comics
A collection of funny comics for programmers.
Marcin Moskała
4/14/2022
Kotlin Coroutines: Deep Dive book is finally ready!
Learn about our recently published book dedicated to Kotlin Coroutines.
Marcin Moskała
4/5/2022
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.
Marcin Moskała
2/21/2022
Flattening flow: flatMapConcat, flatMapMerge and flatMapLatest
Let's learn how can we flatMap flow with flatMapConcat, flatMapMerge, and flatMapLatest.
Marcin Moskała
2/14/2022
Collecting values on flow: fold and scan
Let's learn how can we accumulate flow values with fold and scan.
Marcin Moskała
2/7/2022
Funny programming videos
A collection of funny videos for programmers.
Marcin Moskała
2/1/2022
Combining flows: merge, zip, and combine
Let's learn how can we transform two flows into one, with merge, zip, and combine.
Marcin Moskała
1/31/2022
Flow lifecycle operations
Let's learn about lifecycle operations, controlling context, and handling exceptions in flow.
Marcin Moskała
1/24/2022
Flow building
Every flow needs to start somewhere, so let's explore all the different flow builders.
Marcin Moskała
1/17/2022
Advent of Kotlin Solutions
Solutions to the Advent of Kotlin!
Marcin Moskała
1/2/2022
Advent of Kotlin: Week 4
Week 4 of the Advent of Kotlin: Parsing JSON
Marcin Moskała
12/21/2021
Advent of Kotlin: Week 3
Week 3 of the Advent of Kotlin: k-means clustering
Marcin Moskała
12/14/2021
Advent of Kotlin: Week 2
Week 2 of the Advent of Kotlin: Tree algorithms
Marcin Moskała
12/6/2021
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
Marcin Moskała
12/1/2021
Item 13: 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
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
Constructing a 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
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
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 secondary 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
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 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