0% completed

All LessonsFree Lessons (4)

Getting Started

Introduction Who's This Course for?What's in this course?

Hello Kotlin

Introduction to Kotlin

Reasons to Love Kotlin

Why Should You Choose Kotlin?

Taking Kotlin for a Ride

Compile to Bytecode and Run

Compiling to Other Targets

Which Option to Choose?

Kotlin Essentials for the Java Eyes

Introduction to Kotlin Essentials Less Typing Sensible Warnings Prefer val over var Improved Equality Check String Templates Raw Strings More Expressions, Fewer Statements Wrapping Up

Working with Functions

Introduction to Functions in Kotlin Creating Functions Default and Named Arguments vararg and Spread Destructuring Wrapping Up

External Iteration and Argument Matching

Introduction to External Iteration with Argument Matching Range and Iteration Iterating over Arrays and Lists When It’s Time to Use when Wrapping Up

Using Collections

Introduction to Collections in Kotlin Flavors of Collections Using Pair and Triple Arrays of Objects and Primitives Using List Using Set Using Map Wrapping Up

Type Safety to Save the Day

Introduction to Type Safety in Kotlin Any and Nothing Classes Nullable References Type Checking and Casting Explicit Type Casting Generics: Variance and Constraints of Parametric Types Reified Type Parameters Wrapping Up

Objects and Classes

Introduction to Objects and Classes Objects and Singletons Creating Classes Companion Objects and Class Members Creating Generics Classes Data Classes Wrapping Up

Class Hierarchies and Inheritance

Introduction to Class Hierarchies and Inheritance Creating Interfaces and Abstract Classes Nested and Inner Classes Inheritance Sealed Classes Creating and Using Enums Wrapping Up

Extension Through Delegation

Introduction to Delegation When to Choose Delegation over Inheritance?Designing with Delegates Delegating to a Parameter Dealing with Method Collisions Caveats of Kotlin Delegation Delegating Variables and Properties Built-in Standard Delegates Wrapping Up

Functional Programming with Lambdas

Introduction to Lambdas in Kotlin The Functional Style Lambda Expressions Lambdas and Anonymous Functions Closures and Lexical Scoping Non-Local and Labeled return Inlining Functions with Lambdas Wrapping Up

Internal Iteration and Lazy Evaluation

Introduction to Internal Iteration and Lazy Evaluation External vs. Internal Iterators Internal Iterators Sequences for Lazy Evaluation Wrapping Up

Fluency in Kotlin

Introduction to Fluency in Kotlin Overloading Operators Injecting Using Extension Functions and Properties Extending Functions Function Fluency with infix Fluency with Any Object Implicit Receivers Wrapping Up

Creating Internal DSLs

Introduction to DSLs in Kotlin Types and Characteristics of DSLs Kotlin for Internal DSLs Challenges in Building for Fluency Type-Safe Builders Narrowing Access with Scope Control Wrapping Up

Programming Recursion and Memoization

Introduction to Recursion and Memoization The Power and Perils of Recursion Tail Call Optimization Memoization Applying Memoization to Dynamic Programming Wrapping Up

Exploring Coroutines

Introduction to Coroutines in Kotlin Coroutines and Concurrency Running Concurrently Using Coroutines Coroutine Context and Threads Debugging Coroutines async and await A Peek at Continuations Creating Infinite Sequences Wrapping Up

Asynchronous Programming

Introduction to Asynchronous Programming in Kotlin Programming Asynchronously Exception Handling Cancellations and Timeouts Wrapping Up

Intermixing Java and Kotlin

Introduction Joint Compilation Calling Java from Kotlin Calling Kotlin from Java Wrapping Up

Unit Testing with Kotlin

Introduction to Unit Testing in Kotlin The Code Under Test Getting the Project Files Starting with a Canary Test Writing Empirical Tests Writing Data-Driven Tests Mocking Out Dependencies Testing Top-Level Functions Testing Coroutines and Asynchronous Calls Integrating with the Service Viewing the Code Coverage Taking the App for a Drive Wrapping Up

Programming Spring Applications with Kotlin

Introduction to Spring Applications in Kotlin Creating a Starter Project Creating a Controller Creating an Entity Class Creating a Repository Interface Creating a Service Integrating the Service with Controller Taking It for a Ride Wrapping Up

Writing Android Applications with Kotlin

Introduction to Android Applications in Kotlin Creating a Project Defining Domain Objects Creating Layouts Implementing the Activity Updating the RecyclerView Seeing the App in Action Wrapping Up

Appendix

Transpiling to JavaScript Kotlin/Native Kotlin to WebAssembly

Project

Build a Ktor-Based Backend for a Financial App

The Ultimate Guide to Kotlin Programming/

...

/

Why Should You Choose Kotlin?

Why Should You Choose Kotlin?

We'll cover the following...

- Why do developers prefer Kotlin?

Why do developers prefer Kotlin?

Kotlin may be the right choice for your current project, or the next one, for many reasons:

Kotlin delivers on the “less is more” promise—you write less boilerplate code. The less code you write, the less your team has to maintain, resulting in fewer errors to deal with.
Kotlin gives you the freedom to mix the imperative and functional styles of programming; you pick what’s best for the problem ...