Documenting My Journey as I start Learning Kotlin

Towards the end of last year, I got an interest in learning a new programming language or library/framework for building mobile applications, apart from React-Native, which I had used during my first role for a couple of months. The essence of this article is to document my Kotlin learning journey. I’m a bit inconsistent currently since I still have to improve my frontend skills that I use in my day-to-day activities.

I find learning and building projects continuously is what makes software development more refreshing. I’m more of a web developer and still have a lot of skills, especially around JavaScript (core & frameworks), CSS, and technologies like TypeScript that still need me to upskill on, but starting to learn Kotlin in my free time might make the journey more interesting.

I started looking at Flutter and learned that one has to learn the Dart programming language first before moving to build mobile app projects using Flutter, and the Dart syntax is almost like that of C++, which I’m not yet familiar with. I found a few Flutter tutorials in FreeCodeCamp, but a random thought came to mind when I was just getting started with Flutter to consider checking out Kotlin. I saw that its syntax is favorable for someone with a JavaScript background. I looked into resources from Kotlin's official documentation, some courses on Udacity, and some on YouTube by FreeCodeCamp. I also spoke to a developer who frequently codes with Kotlin, and he shared some resources that have worked for him so far. He recommended some courses on Udacity and this YouTube channel that has a Kotlin Tutorial for Beginners: The Kotlin Programming Language, which he said a mentor recommended to him.

According to Kotlin’s official documentation, Kotlin is a modern but already mature programming language aimed at making developers happier. It's concise, safe, interoperable with Java and other languages, and provides many ways to reuse code between multiple platforms for effective programming.

Kotlin Basics

I have started learning Kotlin basics and just learned by coding along the last youtube tutorial I tagged the instructor recommends using the Integrated Development Environment (Intellij IDEA by Jet Brains) which I had to install and learn how to use GIT/Github on top of it as well as compiling the code after writing it and expecting an output

Steps on how to set up JDK & SDK version 17 on IntelliJ IDEA for Kotlin development

• 1. Open IntelliJ IDEA and go to File > Project Structure.

     2. In the Project Structure window, select SDKs from the left menu.

     3. Click the + button to add a new SDK and select JDK.

     4. Navigate to the location of your JDK 17 installation and select it.

     5. Once the JDK is added, go to File > Project Structure again.

     6. Select Project from the left menu, and ensure that the Project SDK is set to the JDK 17 you just added.

     7. In the same window, go to the Project language level and select 17-Preview and Experimental.

     8. Click Apply and click OK to save the changes.

        Now you should be able to create a new Kotlin project and write code using JDK & SDK version 17 on IntelliJ IDEA.

        Steps on how to start a Kotlin project with a main.kt file in IntelliJ IDEA

1. Open IntelliJ IDEA and click on "Create New Project".

2. Select "Kotlin" as the project type and "JVM | Kotlin/JVM" as the project template.

3. In the next window, give the project a name and select the location where you want to create the project.

4. Click on the "Finish" button to create the project.

5. In the project window, you'll find a file named "main.kt" under the "src" folder. This file is the entry point of your application, and it contains the main function.

6. Open the "main.kt"File in the editor and you can start writing your code.

7. To run the program, you can use the "Run" button on the top menu, or you can press the Shift+F10 key.

8. IntelliJ IDEA will prompt you to choose the main class. Select "main" and click on "OK".

9. The program will then be executed, and the output will be displayed in the "Run"Tab at the bottom of the screen.

Here is a sample code for the main.kt file, which is the entry point of the application

fun main() {
    printLn("hello world!")
}

/* definition of keyword 
- fun: keyword for function 
- main: name of the function which is special 
*/

Kotlin: human-readable & compatible with JVM

• Kotlin source code is designed to be human-readable and compatible with the Java Virtual Machine(JVM).

• The Kotlin compiler takes the human-readable code written in Kotlin and transpilers it into Java bytecode, which is binary code that the JVM can understand.

• This Java bytecode can then be run on any platform that has a JVM installed, e.g, Windows, Mac, or Linux.

• Advantage: This allows developers to write code in a more expressive and readable language while taking advantage of the performance and compatibility offered by the JVM.

  Writing Kotlin Code & Understanding Basic Variables, Syntax, and inBuilt Methods

  Kotlin uses the camelCase naming convention, i.e, the first word in a multi-word identifier is in lowercase and each subsequent word has its first letter capitalized. For example, "helloWorld”

  • Variables can be declared using the:

    • var keyword: used to declare variables and assign a value that can be reassigned

        // a value assigned to it.
        var x = 5

        // without assigning a value, and assign a value later
        var y: Int
        y = 6

        // reassign a value to a variable that has already been declared and assigned a value
        x = 7

• val keyword: used to declare variables and assign a value that cannot be reassigned, i.e, value cannot be changed. It’s the same as const in Javascript

        val name: String = "Sharon Jebitok"

• Kotlin has many inbuilt methods that are available for different contexts. e.g

  • String class:

        length() // returns the number of characters in a string 
        substring(startIndex: Int, endIndex: Int) // returns a new string i.e substring of the original string, starting at the specified startIndex & ending at the specified endIndex-1.
        toLowerCase() // returns a new string with all characters in lowercase
        toUpperCase() // returns a new string with all characters in uppercase
        trim() // returns a new string with leading and trailing whitespace removed
        split(delimiter: String) // returns a list of substrings, split by the specified delimiter
        replace(oldValue: String, newValue: String) // returns a new string with all occurrences of the specified oldValue replaced with the specified newValue

• Collection classes

        filter(predicate: (T) -> Boolean) // returns a new collection containing only elements that satisfy the specified predicate
        map(transform: (T) -> R) // returns a new collection containing the results of applying the specified transform function to each element in the original collection
        reduce(operation: (acc: R, T) -> R) // applies the specified binary operation to the elements in the collection, going left to right, and returning an accumulation of the operation
        forEach(action: (T) -> Unit) // performs the specified action on each element of the collection
        any() // returns true if at least one element in the collection satisfies the specified predicate, otherwise false
        all(predicate: (T) -> Boolean) // returns true if all elements in the collection satisfy the specified predicate, otherwise false

• Numbers

        toInt(): // Converts a number to an integer
        toLong(): // Converts a number to a long
        toFloat(): // Converts a number to a float
        toDouble(): // Converts a number to a double
        abs(): // Returns the absolute value of a number
        round(): // Rounds a number to the nearest whole number
        ceil(): // Rounds a number up to the nearest whole number
        floor(): // Rounds a number down to the nearest whole number
        sqrt(): // Returns the square root of a number
        pow(): // Raises a number to a specified power

• Arrays

        sort(): // sorts the elements of the array in ascending order
        slice(): // returns a subarray that starts at a specified index and has a specified length
        fill(): // fills all elements of the array with a specified value
        copyOf(): // returns a new array that is a copy of the original array
        copyOfRange(): // returns a new array that is a copy of a range of elements from the original array
        forEach() : // Iterates over array elements and perform the given action on each element

• Types of numbers that can be used to represent different ranges of values in Kotlin

  • Byte An 8-bit signed integer. It can hold values from -128 to 127

  • Short A 16-bit signed integer. It can hold values from -32768 to 32767

  • Int A 32-bit signed integer. It can hold values from -2147483648 to 2147483647

    Long A 64-bit signed integer. It can hold values from -9223372036854775808 to 9223372036854775807

  • Float A 32-bit floating-point number. It can hold decimal values

  • Double A 64-bit floating-point number. It can hold decimal values and is the default type for decimal numbers in Kotlin.

        val d: Double = 3.14 //Double 
        var b: Byte = 100 // Byte
        val f: Float = 3.14f // Float
        val l: Long = 10000000000 // Long
        val i: Int = 100000 // Int
        val s: Short = 10000 // Short

• // main.kt file with sample code of inbuilt methods & variables

fun main() {
    var fullName: String = "Sharon Jebitok"
    var age:Int = 26
//    numbers
    val myByte: Byte = 8 // 8-bit signed integer
    val myShort: Short = 16 // 16-bit signed integer
    val myInt: Int = 32 // 32-bit signed integer
    val myLong: Long = 64 // 64-bit signed integer

//    decimals
    val myFloat: Float = 32.00F // 32-bit floating point number
    val myDouble: Double = 64.00 // 64-bit floating point number

    val bigLong: Long = 1_000_000
    println(bigLong)

    val newInt = myInt.plus( other = 12)

    println(newInt)
//    println(bigLong)
//    println(myByte.toDouble()::class)
//    println(myByte.toShort()::class)
//    println(myByte.toLong()::class)
//    println(myByte.toFloat()::class)
//    println(myByte.toInt()::class)
//    println(myByte.toByte()::class)
}

Thank you for reading through my article. You can leave a comment if you’re aware of a better way to learn Kotlin, or maybe you’re also getting started and need a buddy. I would like to acknowledge the tutorial I've been using and ChatGPT; their resources have come in handy in understanding the basics and also putting together this article.