Getting Started

Get an overview of the content of this course and learn how design patterns can be easily adopted in Kotlin.

Design patterns enable you as a developer to speed up the development process by providing you with proven development paradigms. Reusing design patterns helps prevent complex issues that can cause major problems, improves your code base, promotes code reuse, and makes an architecture more robust.

The objective of this course is to ease the adoption of design patterns in Kotlin and provide good practices for programmers.

The course begins by showing you the practical aspects of smarter coding in Kotlin, explaining the basic Kotlin syntax and the impact of design patterns. From there, the course provides an in-depth explanation of the classical, creational, structural, and behavioral design pattern families, before heading into functional programming.

It then takes you through reactive and concurrent patterns, teaching you about using streams, threads, and coroutines to write better code along the way.

By the end of the course, you will be able to efficiently address common problems faced while developing applications and be comfortable working on scalable and maintainable projects of any size.

Who this course is for

This course is for developers who would like to master design patterns with Kotlin in order to build reliable, scalable, and maintainable applications. Prior programming knowledge is highly advised in order to get started with this course. Prior design pattern knowledge would be helpful, but is not mandatory.

What this course covers

In this course, we will cover the basic syntax of the Kotlin programming language and the implementation of all the classical design patterns in Kotlin. The classical design patterns deal with three major problems in system design:

  • How to create objects efficiently
  • How to encapsulate object hierarchies
  • How to make object behavior more dynamic

We’ll discuss which design patterns come as part of the language, and how to implement those that don’t.

Then we’ll focus on modern approaches to design patterns, such as reactive and concurrent design patterns, and functional programming in general. We’ll have an introduction to the basic principles of functional programming and how its concepts are embedded in Kotlin. Then, we’ll examine concurrency primitives in Kotlin, the most important being coroutines. Once we have a good grasp of both functional programming and coroutines, we’ll then see how, by combining them, we can create concurrent data structures that allow us to finely control the flow of our data and the design patterns that allow us to better structure concurrent code.

Press + to interact
Classical to modern approaches to design patterns
Classical to modern approaches to design patterns

And at the end of this course, we will apply our knowledge of design patterns to implement a real-world application and learn some best practices and anti-patterns.

We’ll begin with the collection of best practices and things to avoid while developing applications using Kotlin. Then we will build two microservices:

  • Using a concurrent framework called Ktor

  • Using a reactive framework called Vert.x

We’ll also use this opportunity to examine how the design patterns we’ve seen come into play in real-world applications.