x

Confirm Download

Simultaneous file downloading works best in FireFox, Chrome, and Safari browsers. Please keep this window open until all downloads are complete. Some customers prefer using file download managers for Chrome or Firefox to better manage large and multiple file downloads.

Cancel Download

Introduction to Kotlin Programming

      • Welcome to the Course  (Free)

        This course is for software developers and architects that are new to Kotlin (and potentially the JVM). We'll take a full tour of the language and build up enough concepts for you to become familiar with Kotlin in order to start writing code.
      • 00:00:48

      • Why Kotlin  (Free)

        With so many languages on the market, what made JetBrains create a new one, and what does this language offer?
      • 00:07:28

      • Introduction to the JVM  (Free)

        An overview of the Java Virtual Machine as a platform and an ecosystem, and where Kotlin sits on top of this platform and its relation to Java.
      • 00:04:45

      • Installing the Tooling

        We'll see the tools that are required for working with Kotlin and how to install these based on your operating system.
      • 00:04:15

      • The Kotlin REPL

        The Kotlin compiler comes with a Read, Evaluate, Print Loop. Get a first taste of the Kotlin language inside the REPL.
      • 00:04:40

      • The Structure of a Kotlin Application

        Understand the different parts of what makes a Kotlin application, including packages, entry points and other constructs needed to start writing applications
      • 00:10:43

      • Conventions Used with Kotlin & Summary

        This segment offers a short overview of the conventions that will be used when writing Kotlin Code. This segment also summarizes tooling, Kotlin REPL, and other topics detailed so far.
      • 00:02:28

      • Loops and Ranges in Kotlin

        A look at the way Kotlin handles for, while, and do loops, as well as the ability to iterate through a range of values.
      • 00:08:06

      • Packages and Imports in Kotlin & Summary of Kotlin Basics

        Kotlin organizes types by packages, allowing us to organize code in specific areas and import entire packages for what is specifically needed. This segment also summarizes the ideas we've covered that constitute the basics of Kotlin.
      • 00:03:31

      • Functions in Kotlin

        Functions are one of the basic building blocks in Kotlin. We'll see how they are declared, invoked, and the features functions offered in this language.
      • 00:07:12

      • Functions with Default and Named Parameters in Kotlin

        Kotlin allows default parameters, which make things quite useful when wanting to call functions with multiple parameters and only provide a few in different scenarios. This segment also explains optional and default parameters.
      • 00:05:45

      • Classes in Kotlin

        As an object-oriented programming language, classes constitute one of the main building blocks of Kotlin applications. We'll cover the basics of classes and properties.
      • 00:15:39

      • Member Functions in Kotlin

        This segment offers a look at functions as part of classes and how they can interact with class properties.
      • 00:01:51

      • Kotlin Data Classes

        Data classes offer a series of advantages of regular Kotlin classes, enabling us to drastically cut down on boilerplate code.
      • 00:10:37

      • Enum Classes in Kotlin

        Kotlin allows us to use enum classes to define a set of values. Each enum object is actually an object that enables additional functionality.
      • 00:08:48

      • Objects in Kotlin & Summary

        Not only can we create instance of classes, we can also have first-class objects and usage in patterns such as singletons. This segment also summarizes what we've seen for Classes in Kotlin.
      • 00:03:53

      • Inheritance in Kotlin

        Kotlin offers inheritance of classes, but it also has a certain particularity, which we'll see in this segment. Data classes can often benefit from an inheritance model when working with frameworks such as object-relational mappers. Kotlin provides support for data class inheritance.
      • 00:05:52

      • Interfaces in Kotlin

        In Kotlin interfaces, much like in Java 8, not only the means of defining a contract are offered, but also default implementations. What makes them different than abstract classes then?
      • 00:08:56

      • A Brief Look at Generics in Kotlin & Summary

        Kotlin has support for generics and we'll cover the basic concepts around generics, including upper bounds, and so on in this segment. This segment also summarizes class inheritance, interfaces, and other topics covered.
      • 00:07:38

      • Null Safety & Summary

        Kotlin is a null safe language, meaning types by default cannot be null. This provides a series of benefits that we can examine in this segment, as well as how to deal with nulls when needed. This segment also summarizes working with nulls in Kotlin.
      • 00:13:22

      • Type Casting in Kotlin

        Kotlin offers two variants of type casting: manual and automatic, which saves substantially on boilerplate code.
      • 00:07:11

      • Tuples

        Sometimes we might want to work with more than one value but not go fully fledged into use Data classes. That's where Tuples come in.
      • 00:03:48

      • Deconstructing values

        When working with values, especially tuples, it's very useful to have some more semantics into the actual values. We can use value deconstruction to do so.
      • 00:06:56

      • Working with Exceptions

        Exceptions in Kotlin are different to that of Java, in that there are no checked exceptions. Other than that though, working with exceptions is pretty straightforward.
      • 00:11:12

      • Declaring Constants

        In Kotlin, there are a few ways we can define what would be the equivalent of constants and top-level properties.
      • 00:02:08

      • Annotations in Kotlin & Summary

        Kotlin provides a series of annotations that allow for defining certain metadata around the code, working with frameworks, as well as interoperability with Java. This segment also summarizes the different nuggets we've seen so far.
      • 00:03:22

      • Higher-Order Functions in Kotlin

        Kotlin allows for higher-order functions, meaning that functions can take functions as parameters or return these. We'll see how to declare such functions.
      • 00:05:05

      • Lambda Expressions in Kotlin

        In addition to declaring functions providing their names, Kotlin also allows us to use lambda expressions for certain cases.
      • 00:11:21

      • Closures in Kotlin

        When a lambda expression references variables of the function in which it's contained, this forms a closure, and it has some gotcha's we need to be aware of.
      • 00:03:14

      • Extension Functions in Kotlin & Summary

        One of Kotlin's great strengths is the ability to extend classes with new functionality without having to inherit from these. That's what extension functions are. This segment also summarizes all the goodies of functions.
      • 00:10:55

      • Interoperability with Java

        One of Kotlin's strengths is the ability to easily interoperate with Java and existing Java frameworks and libraries, something we'll cover in this part.
      • 00:02:11

      • Talking to Java from Kotlin

        Calling Java from Kotlin is straightforward, but following a series of conventions, it can make the code look even smoother.
      • 00:07:53

      • Working with nulls from Java

        Kotlin is a null-safe language, but when working with Java, many methods can return null. We'll see how to deal with these situations.
      • 00:06:37

      • Talking Kotlin in Java

        The gotchas of working with overloaded methods, field access, or dealing with checked exceptions when calling Kotlin code from Java.
      • 00:12:14

      • Extension Functions from Java

        Extension functions are another feature that is only available in Kotlin. However, despite this, they can in fact still be invoked from Java.
      • 00:01:33

      • Interop with Java 7 and 8 & Summary

        While Kotlin is compatible with Java 6, if your code is targeting Java 7 or 8, the compiler can make use of certain constructs for purposes of optimization. This segment also summarizes the different ways in which we can interoperate between Kotlin and Java.
      • 00:02:16

      • Kotlin Standard Library and Working with Collections in Kotlin

        The Kotlin standard library is small, but it offers a series of functions that can make development much smoother. We'll see some of the most common ones. Kotlin also doesn't provide its own collections over Java, but it does provide a series of interfaces that are geared towards immutability, and the standard library allows us to work with these.
      • 00:11:13

      • Lazy Evaluation with Sequences in Kotlin

        By default, collections in Kotlin are eagerly evaluated, contrary to streams in Java. However, Kotlin does provide a method by which we can do lazy evaluation of collections.
      • 00:08:47

      • String Extensions in Kotlin & Summary

        The ability in Kotlin to provide extensions functions, opens up the door to strings have a slew of helpful functions to operate on them. This segment also summarizes some of the more common functions that are provided in the Standard Library.
      • 00:04:06

      • Build Tools in Kotlin & Summary

        Up to now, all samples have been using the IntelliJ IDEA build system. However, Kotlin can be used with any build tool, including Maven and Gradle. This segment also offers a quick overview of the options available when building Kotlin applications.
      • 00:03:56

Introduction to Kotlin Programming

  • Publisher: O'Reilly Media
  • Released: October 2016
  • Run time: 5 hours 15 minutes

Kotlin 1.0 was released in February 2016, and since that time it’s been embraced by developers around the world, especially those within the Android community. This course provides an easy introduction to this open source programming language that covers the basics and showcases the language’s interoperability with Java and the JVM platform. A key feature of Kotlin is its similarity to Java, C#, and JavaScript. If you’re familiar with any of these languages, says expert trainer Hadi Hariri, take this course and you’ll understand Kotlin on day one.

  • Get a full tour of language basics and learn to start writing Kotlin code
  • Gain an in-depth understanding of why Android developers flock to Kotlin
  • Discover Kotlin’s easy interoperability with Java frameworks, libraries and the JVM
  • Understand the advantages of Kotlin compared to Java and Scala
  • Employ code examples available via Github

Hadi Hariri is VP of Developer Advocacy at JetBrains, the organization behind the creation of Kotlin. He's been speaking at software industry conferences for over 15 years and is well respected within the open source community. He’s the original author of Spek and Wasabi, amongst other OSS projects. He’s been closely involved in Kotlin for more than four years. Hadi is easily accessible on Twitter at @hhariri.