Kt. Academy Logo
WorkshopsCoursesBooksArticles

Marcin Moskała

Marcin Moskala is an experienced developer and Kotlin trainer. He is the founder of the Kt. Academy, an official JetBrains partner for Kotlin training, author of the books Effective Kotlin, Kotlin Coroutines, Functional Kotlin and Android Development with Kotlin. He is also the main author of the biggest medium publication about Kotlin and a speaker invited to many programming conferences.

An experienced trainer who thought on many international companies including IBM, Allegro, Pega, HPE. The author of the books Effective Kotlin and Android Development with Kotlin.

Request company consultations
600 EUR / DAY
Request private consultations
50 EUR / H

Workshops

Effective Kotlin

Kotlin workshop directed to experienced Kotlin developers, focused on the best practices.

More information

Functional Kotlin

Leverage your skills and improve your productivity with functional programming features in Kotlin.

More information

Kotlin for Developers

Kotlin workshop that covers the whole material needed for efficient and idiomatic Kotlin development.

More information

Kotlin for Android Developers

Kotlin workshop that covers the whole material needed for efficient and idiomatic Kotlin development in Android.

More information

Kotlin Coroutines

Workshop covering asynchronous programming in Kotlin using coroutines.

More information

Testing in Kotlin

Practical workshop dedicated to testing in Kotlin, using testing libraries and testing coroutines.

More information

Kotlin Flow

Practical training concentrated on Kotlin Coroutines Flow, using it in real-life use-cases and testing it.

More information

Books

Marcin MoskałaThe author:
Marcin Moskała
Marcin MoskałaThe author:
Marcin Moskała
Marcin MoskałaThe author:
Marcin Moskała
Marcin MoskałaThe author:
Marcin Moskała
Marcin MoskałaThe author:
Marcin Moskała
Marcin MoskałaThe author:
Marcin Moskała

Published articles

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.

Generics in Kotlin

The essence of how generics work in Kotlin.

Kotlin Coroutines use cases for Domain Layer

How do we use Kotlin Coroutines in the Domain Layer.

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.

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.

Item 11: Design for readability

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

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.

Item 5: Specify your expectations for arguments and state

How do we specify requirements and expectations in Kotlin.

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.

DSL type-safe builders

How to define type-safe DSL builders in Kotlin.

Collection processing in Kotlin: Ending

The closing article of the collection processing series, where we will learn about joinToString, and general ideas regarding processing different kind of objects in Kotlin.

Collection processing in Kotlin: Windowing, zipping and chunking

Let's learn about two most mysterious collection processing functions: windowing and chunking.

Lambda expressions

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

Collection processing in Kotlin: Sorting, shuffling and reversing

Sorting elements using their order, or by key, or by multiple keys... Learn about sorting collections in Kotlin.

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.

Collection processing in Kotlin: Associating elements

How do we transform collections into maps using associating functions.

Function types

What is a function type, and what less known features it offers.

Essential programming nomenclature

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

Collection processing in Kotlin: Grouping elements

How do we group collection elements in Kotlin, and how is that useful in a variety of algorithms.

Collection processing in Kotlin: Finding, counting, and checking conditions

Let's learn about finding elements, counting those that fulfill a predicate, or checking predicates for all elements.

Function references

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

Collection processing in Kotlin: drop and take

How to take the first n elements? Of all except the first n? Let's learn about drop, take, dropLast and takeLast.

Collection processing in Kotlin: Using indices

Just because we use use functional processing function, does not stop us from using indices. Let's learn about withIndex and indexed variants of important functions.

Collection processing in Kotlin: Folding and reducing

Folding stands behind nearly all collection processing functions. fold and reduce are our super agents, we can use whenever we cannot find more specific collection processing function.

Collection processing in Kotlin: Basic functions

One of the most useful applications of functional programming is collection processing. Let's learn about essential collection processing functions. That is also a start of a series of articles about functional collection processing functions.

Co można robić w Pythonie?

Najpopularniejsze zastosowania języka Python, oraz jak z nimi zacząć.

Tworzenie serwisów internetowych w Pythonie

Czym są serwisy internetowe i jak utworzyć najprostszy taki serwis w języku Python.

Zbieranie danych w Pythonie

Jak użyć języka Python do zbierania danych ze stron i portali internetowych.

How to write a technical book?

A guide for writing technical books.

Sztuczna inteligencja w Pythonie

Jak zacząć przygodę ze sztuczną inteligencją w języku Python.

Analiza danych w Pythonie

Jak zacząć przygodę z analizą danych w języku Python.

Code or No-code?

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

Gra w węża, część 3: Przejmujemy sterowanie

Jak reagować na akcję gracza, by nasz wąż nabrał życia.

Gra w węża, część 2: Zmiana stanu

W stylu TDD implementujemy poruszanie się węża oraz pozostałe elementu mechaniki gry.

Gra w węża, część 1: Daj mi okno na świat

Jak działają gry oraz jak zacząć pracę z pakietem PyGame.

Instalacja pakietów w Pythonie

Czym jest pip i jak w języku Python instalujemy pakiety.

Funny programming comics

A collection of funny comics for programmers.

Importowanie w Pythonie

Jak w języku Python działa importowanie modułów, pakietów i elementów.

Flow under the hood: how does it really work

We will explore how flow and its processing really works.

Operatory w Pythonie

Czym jest ten cały __eq__, __str__ i pozostałe funkcje stanowiące wsparcie dla nadpisywania operatorów.

Kotlin Coroutines: Deep Dive book is finally ready!

Learn about our recently published book dedicated to Kotlin Coroutines.

List comprehensions w Pythonie

Czym jest List comprehensions i jak wykorzystujemy je do przetwarzania list.

Listy w Pythonie

Jak działa lista i tuple, jak wyciągać i ustawiać wartości poprzez index i zakres, i wiele więcej.

Klasy i obiekty w Pythonie

Czym są klasy i jak przy ich pomocy tworzymy obiekty w języku Python.

Funkcje w Pythonie

Poznamy funkcje, parametry, argumenty, wartości zwracane, domyślne oraz nazwane argumenty.

Pętle w Pythonie

Poznamy pętlę for i while oraz ich najistotniejsze użycia w języku Python.

Wyrażenia logiczne w Pythonie

Dowiemy się, jak działają operatory logiczne and, or i not oraz jak przy ich pomocy tworzymy wyrażenia logiczne.

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.

Warunki w Pythonie

Dowiemy się, jak działa warunek if, else, elif, pass oraz dowiemy się co zrobił Jasio, aby pójść do kina.

Flattening flow: flatMapConcat, flatMapMerge and flatMapLatest

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

Zmienne w Pythonie

Dowiemy się, jak definiować zmienne, jak je nazywać, czym jest None oraz jak przypisać wartości do wielu zmiennych jednocześnie.

Collecting values on flow: fold and scan

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

Wartości w Pythonie

Nauczymy się czym są i jakie są podstawowe wartości w Pythonie. Sprawdzimy też, czy może on nam służyć jako kalkulator.

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.

Pierwszy program w Pythonie

Napiszemy pierwszy program, a także nauczymy się czym jest programowanie, jak przygotować środowisko oraz jak korzystać z tych materiałów.

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

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

Item 13: 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.

Coroutine builders

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

Akcja "Podaj dalej"

Zaczynamy akcję "Podaj dalej" książki JavaScript od podstaw, w ramach której popularyzować będziemy umiejętności programistyczne.

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.

Przyszłość programowania

Analiza stanu branży programistycznej i jaka w związku z tym czeka ją przyszłość.

Napiszmy grę w JavaScript: Wprowadzamy podejście obiektowe

Porządkujemy grę poprzez użycie obiektów, a potem klas.

Jak zostać programistą?

Plan, jak krok po kroku nauczyć się programowania i zostać programistą.

Kt. Academy new logo: Phoenix

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

Napiszmy grę w JavaScript: Lot kulki

Sprawiamy, aby piłeczka się odbijała i wracała na środek, oraz żeby punkty się dodawały. Gra staje się grywalna.

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?

Nauka programowania na telefonie

Smartfon, jako świetne narzędzie do nauki programowania.

Napiszmy grę w JavaScript: W odpowiedzi na Twoje kliknięcie

Uczymy się reagować na kliknięcia użytkownika.

Gry w służbie programowania

Gry, które wspomagają naukę programowania.

Napiszmy grę w JavaScript: Stan oraz stałe

Do naszej gry wprowadzamy pojęcia stanu oraz stałych.

Napiszmy grę w JavaScript: Daj mi płótno, a namaluję świat

Pisanie naszej gry zaczynamy od rysowania elementów: piłeczki, paletek i punktacji.

Rozwiązania do zadań: JavaScript od podstaw

Zebrane rozwiązania do zadań ze wszystkich rozdziałów

Funkcje strzałkowe w JavaScript

Dowiemy się czym są oraz jak wykorzystywać popularne współcześnie funkcje strzałkowe.

Iteracja po tablicy w JavaScript

Nauczymy się iterować po tablicach i poznamy nowoczesne funkcje forEach, map oraz join.

Tablice w JavaScript

Dowiemy się czym są tablice, jak dodawać i wyciągać z nich wartości, a także jak sprawdzić ich wielkość.

Jak nauczyć się programowania?

Jak można uczyć się programowania: kursy online, YouTube, bootcampy... pomówmy o nich po kolei.

Elementy programowania obiektowego w JavaScript

Dodamy naszym programom trochę klasy dzięki metodom, operatorowi new oraz przy użyciu samych klas.

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

Obiekty w JavaScript

Dowiemy się czym są obiekty i pola, jak je modyfikować oraz co się dzieje, gdy ich brak. Poznamy też format JSON.

Funkcje w JavaScript

Poznamy najważniejszą funkcjonalność języka: funkcje. Dowiemy się czym są parametry i argumenty, a także jak przekazywać funkcje do funkcji.

Co można robić w JavaScript?

Pisanie stron, botów, robotów... co jeszcze można zrobić przy użyciu JavaScript?

Wyrażenia logiczne w JavaScript

Jak działają operatory i && oraz lub ||.

Pętle w JavaScript

Poznamy pętle while i for, jak również dowiemy się, jak zazwyczaj są one używane.

Warunki w JavaScript

Dowiemy się jak działają warunki if, if-else oraz if-else-if, poznamy wyrażenia i operatory logiczne oraz sprawdzimy, co zrobił Jasio, aby pójść do kina.

Zmienne w JavaScript

Dowiemy się czym są i jak działają zmienne, co różni const i let oraz jak je nazywać, skąd wziął się camelCase, a także czym są null i undefined.

Wartości w JavaScript

Nauczymy się czym są i jakie są podstawowe wartości i typy w JavaScript. Sprawdzimy też, czy JavaScript może nam służyć jako kalkulator.

Pierwszy program w JavaScript

Napiszemy pierwszy program, a także nauczymy się czym jest programowanie, jak przygotować środowisko, oraz jak korzystać z tych materiałów.

Reviewed articles

A birds-eye view of Arrow: Error Handling

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

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.

Persistent memory design choices and use-cases

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

Persistent dictionary

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

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.