Part 1 : Getting Started With Kotlin
Tags: kotlin, beginners, programming
Published: 2022-07-18 09:52:49

## Motivation

This article is written for more advanced developers which are looking to get a quick grasp on the Kotlin Language for work or for some interesting projects. 

We cover installation, basic syntax and a quick introduction to functions in this article which is Part 1 in a long series.

- **Part 1 : Getting Started with Kotlin**
- Part 2 : [Control Flow in Kotlin]( https://dev.to/ivanleomk/part-2-control-flow-with-kotlin-2lfh )
- Part 3 : Loops and Exceptions in Kotlin ( Coming Soon )


## Installation

For this specific tutorial, I recommend using VsCode since it has almost everything you will need. 

1. First, install the Kotlin language using Homebrew.

```
brew update
brew install kotlin
```

2. Next, install VsCode Support for Kotlin using the [Kotlin extension](https://marketplace.visualstudio.com/items?itemName=fwcd.kotlin) and [Code Runner](https://marketplace.visualstudio.com/items?itemName=formulahendry.code-runner).

3. Lastly, create a new file called `test.kt` with the following code within it. 

> In Kotlin, we always begin our program with the `main` function. This function is always named the same and does not take any parameters.

```kotlin
fun main() {
    println("Hello, world!!!")
}
```

which we can then run by using the code runner extension. If all is good, we should get the output as 

```terminal
[Running] cd <filePath> && kotlinc main.kt -include-runtime -d main.jar && java -jar main.jar
Hello, world!!!

[Done] exited with code=0 in 7.21 seconds
```

Congratulations! You've successfully installed Kotlin 🎉🎉🎉 !!


## Programming With Kotlin

### Var vs Val

While there are a variety of nuances to consider when deciding whether to use a Var and a Val, an important consideration is that

> A Var is a mutable reference while a Val is an immutable one.

A good rule of thumb is to therefore minimise the use of Vars while sticking to Vals as much as possible. 

### Types

We use types in Kotlin in order to avoid any potential typing errors which might result in unforeseen problems. We can annotate types in Kotlin by using the command

```kotlin
val one:Int = 1
``` 

Kotlin by default gives us the Types of

- Int
- Double
- Boolean
- String
- Char
- String

Which we can annotate as seen above. If we do not annotate the type of a variable, Kotlin will simply infer its type.

### Functions

We can also write more complex helper functions which we can call and utilise. Functions take the generic boilerplate version of

```
fun <nameOfFunction>(parameter_1:type_1,...){
//Function Code Goes Here
}
```

We can see an example below of a function which multiplies two numbers together

```kotlin
fun multiplyByN(x:Int,y:Int):Int = x * y
```

> **Note** :  Our function takes in two arguments and can be expressed in a single line. As a result, we can write it without using the two curly braces we normally use.

We can also make our function more extensible by using default arguments. Let's rewrite our `multiplyByN` function with some default arguments.


```kotlin
fun multiplyByN(x:Int,y:Int=4):Int = x * y
```

As you can see, by adding a default argument of 4, the two function calls below are now identical.

```kotlin
fun main() {
    println(multiplyByN(3))
    println(multiplyByN(3,4))
}

fun multiplyByN(x:Int,y:Int=4):Int = x * y
```

which we can verify by running it using the CodeRunner extension.

```bash
[Running] cd <filePath> && kotlinc main.kt -include-runtime -d main.jar && java -jar main.jar
12
12

[Done] exited with code=0 in 4.687 seconds
```