WorkshopsCoursesBooks

Extra tools

Articles

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

Flow under the hood: how does it really work

We will explore how flow and its processing really works.

Marcin Moskała
4/11/2022

Kotlin Coroutines book is finally ready!

Find out for whom Kotlin Coroutines was created and what this book is about.

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

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

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