Introduction to Kotlin¶

Kotlin is a programming language that is designed to be concise, safe, and expressive. It is runs on multiple platforms, including JVM, Android, browsers, and even natively on computers!

Why Kotlin?¶

In the past, our team has used Java as our primary programming language. However, we have decided to switch to Kotlin. Here's why:

• Conciseness, multi-paradigm structure and interoperability
• As a first programming language, gradual introduction of programming concepts without confusing boilerplate
• Learn modern, generalizable programming habits which can be applied to use in the industry

Kotlin in Industry and Academia¶

Kotlin has already established itself to be highly impactful in sectors including mobile development, and server-side & cloud development. Additionally, Kotlin is trending in fields such as Multiplatform development, web frontend development, data science & machine learning, and desktop application development.

Features¶

Concise Code¶

Compared to Java, an industry standard, Kotlin is much more concise - reducing the number of lines of code by 40% on average. This, paired with a simple syntax, allows us to focus on the actual ideas behind our code and programming.

Multi-Platform¶

Kotlin is a multi-platform language, meaning that code can be run or executed across multiple platforms. Essentially, this allows us to write code once, and run it anywhere.

graph LR
    S[Source Code]
    M[Machine Code]
    C[Computer]

    S -- Compiler --> M -- Runs On --> C

graph LR
    S[Source Code]
    B[Bytecode]
    M[JVM]

    subgraph P[JVM Platforms]
        Android
        Windows
        MacOS
        Linux
    end

    S -- Compiler --> B -- Run the Program --> M -- Runs Anywhere --> P
    S -. Runs Once .-> B

graph LR
    S[Source Code]
    B[Bytecode]
    M[JVM]
    W[Web Assembly]
    Br[Browser]
    I[iOS]

    subgraph P[JVM Platforms]
        Android
        Windows
        MacOS
        Linux
    end

    K[Native Code] 

    S -- Compiler --> B -- Run the Program --> M -- Runs Anywhere --> P
    S -- Compiles --> W --> Br
    S -- Compiles --> K --> P
    K --> I

Static Typing¶

Static typing is a way of defining the data types of variables and expressions in a programming language, enforcing the type of operations that can be performed on data.

What is Typing?¶

Why does this typing matter though? Let's break this down into a couple of exercises. Think of what result you would get if you were to perform the following operations:

As shown in the examples above, static typing allows us to define the type of operations that can be performed on data. In this case, adding two words will concatenate them together, while adding two numbers will mathematically add them together.

In other words, the operation performed on data is dependent on the type of data. This is the core idea behind any typing.

Enforcing Type Safety¶

Static typing also allows us to enforce types - meaning that the type of element must remain a specific type at any given time. This means that we can prevent operations from being performed on data that is not defined for that type.

For example, if we were to try to add a word with a number, we would get an error. This is because the + operator is not defined for words and numbers.

Type Inference¶

Type inference is a way of automatically determining the type of a variable or expression. This allows us to write code without having to explicitly define the type of a variable or expression - it saves us time and makes our code more concise.

For example, if we were to define a variable name and assign it the value "John", we would not have to explicitly define the type of name as a word. Instead, Kotlin would automatically infer that name is a word. Note that typing still exists, and add operations on name would still result in concatenation.

Null Safety¶

Kotlin enforces null safety, meaning that we cannot assign a variable to null unless we explicitly define it as it being nullable. This prevents us from encountering null pointer exceptions, an extremely common error in Java.

Hello World¶

Your turn! Let's write our first Kotlin program.

fun main() {
    println("Hello World!")
    // Hello World!
}

This is a simple program that prints Hello World! to the console. Let's break it down.

• fun is used to declare a function.
• The main function is where your program starts from - it's the entry point to the program.
• The body of a function is written between curly braces {}.
• println is a function that prints a line to the console.