DEV Community: Kotlin

Idiomatic Kotlin: Solving Advent of Code Puzzles, Binary Boarding

Svetlana Isakova — Fri, 10 Sep 2021 08:50:58 +0000

Let’s continue our journey of understanding what “idiomatic Kotlin” means and solve one more puzzle from the Advent of Code challenge. The puzzles are independent of each other, so you don’t need to check any of the previous ones we’ve already covered. Simply read through the following solution or watch the video. We hope you learn something new!

Day 5. Binary Boarding

We’re boarding the plane! We need to analyze the list of boarding passes and find the seat with the highest seat ID. Then we need to find the one seat missing from the list, which is ours. You can find the full task description at https://adventofcode.com/2020/day/5.*

A seat is specified as, for example, FBFBBFFRLR, where F means "front", B means "back", L means "left", and R means "right". The first 7 characters are either F or B and they specify exactly one of the 128 rows on the plane (numbered 0 through 127). The last three characters are either L or R; these specify exactly one of the 8 columns of seats on the plane (numbered 0 through 7). A more detailed encoding description is given on the puzzle page.

Every seat has a unique seat ID, calculated by multiplying the row by 8 and then adding the column.

The puzzle input is the list of boarding passes. The first task is to find the boarding pass in this list with the highest seat ID.

The second task is to find the missing boarding pass in the list. The flight is completely full, there’s only one missing boarding pass, and that’s our seat. However, some of the seats at the very front and back of the plane don't exist on this aircraft, so they are missing from the list as well.

As usual, we suggest that you try to solve the task on your own before reading the solution. Here’s how you can set up Kotlin for this purpose.

Solution

Let’s first discuss the encoding of the boarding passes. Note how it is a nicely “hidden” binary representation of natural numbers! Let’s take a closer look.

Boarding pass: binary representation

First, let’s look at the rows. There are 128 rows on the plane, which are encoded with 7 “bits”. These bits are called F and B in the puzzle, but they carry the same meaning as 0 and 1 do in the binary representation. To extend the analogy, the way to identify the exact row based on the boarding pass is reminiscent of the algorithm used to convert a binary representation of the number to a decimal.

Let’s consider the provided example – the first seven characters of FBFBBFFRLR that decode the “row”. F means to take the “front”, or the lower half, while B is to take the “back”, or the upper half on each iteration. Taking the lower half is equivalent to not adding the corresponding power of two to the result (or multiplying it by zero), while taking the upper half is equivalent to adding it to the result (or multiplying it by one).

F = 0; B = 1
FB notation  F  B  F  B  B  F  F
Bit          0  1  0  1  1  0  0
Index        6  5  4  3  2  1  0
2^Index      64 32 16 8  4  2  1

Decimal:
0 * 2^6 + 1 * 2^5 + 0 * 2^4 + 1 * 2^3 + 1 * 2^2 + 0 * 2^1 + 0 * 2^0 =
32 + 8 + 4 = 
44

If this conversion is clear to you, you can skip the remaining explanations in this section and go directly to the Kotlin implementation. If not, please read the description of the conversion strategy on the task page and the following explanations carefully.

We start by considering the whole range, rows 0 through 127. The maximum value that can be decoded via 7 bits is 1111111, or 127 if converted to the decimal form: 2⁷ - 1 = 2⁶ + 2⁵ + 2⁴ + 2³ + 2² + 2¹ + 2⁰ = 127. Each bit is responsible for its part of the range: if it’s 1, we add the corresponding power of two to the result; if it’s 0, we skip it.

Bit	Bit index	Description of the task	Reworded in ‘binary representation’ terms
`F = 0`	`6`	`F` means to take the lower half, keeping rows 0 through 63.	We don’t add `2⁶=64` to the result. That keeps the result in the `0..(127-64)` range, or `0..63`.
`B = 1`	`5`	`B` means to take the upper half, keeping rows 32 through 63.	We add `2⁵=32` to the result. That keeps the result in the range `32..63`.
`F = 0`	`4`	`F` means to take the lower half, keeping rows 32 through 47.	We don’t add `2⁴=16` to the result. That makes the possible range `32..(63-16)`, or `32..47`.
`B = 1`	`3`	`B` means to take the upper half, keeping rows 40 through 47.	We add `2³=8` to the result. That keeps the result in the range `(32+8)..47`, or `40..47`.
`B = 1`	`2`	`B` keeps rows 44 through 47.	We add `2²=4` to the result. That keeps the result in the range `(40+4)..47`, or `44..47`.
`F = 0`	`1`	`F` keeps rows 44 through 45.	We don’t add `2¹=2`. That makes the possible range `44..(47-2)`, or `44..45`.
`F = 0`	`0`	The final `F` keeps the lower of the two, row 44.	We don’t add `2⁰=1`. That makes the result `44..(45-1)`, or simply `44`.

Decoding column

Decoding the column follows the same logic, but now R takes the upper half and corresponds to bit 1, while L takes the lower half and corresponds to bit 0.

Let's now consider the last 3 characters of FBFBBFFRLR.

L = 0; R = 1
RL notation  R  L  R
Bit          1  0  1
Index        2  1  0
2^Index      4  2  1

Decimal:
1 * 2^2 + 0 * 2^1 + 1 * 2^0 =
4 + 1 = 
5

The whole range represents columns 0 through 7. It’s the maximum value that can be encoded via three bits: 2² + 2¹ + 2⁰ = 7.

R means to take the upper half, keeping columns 4 through 7. In other words, take 2²=4 with the multiplier "1".
L means to take the lower half, keeping columns 4 through 5. In other words, take 2¹=2 with the multiplier "0".
The final R keeps the upper of the two, column 5. In other words, take 2⁰=1 with the multiplier "1", making the result 4+1=5.

The last part is converting the row and the column numbers to the seat ID by using the formula: multiply the row by 8 and then add the column. For the sample boarding pass, the row is 44 and the column is 5, so this calculation gives the seat ID as 44 * 8 + 5 = 357.

Combining row and column

But if we look closer at this formula, we’ll notice that we don’t need to find the row and column separately! We can simply add all the row bits with indexes increased by three to the result (note that 8 = 2³). This bit operation is formally called “left-shift”.

FBRL notation  F  B  F  B  B  F  F  R  L  R
Bit            0  1  0  1  1  0  0  1  0  1
Index          9  8  7  6  5  4  3  2  1  0

Decimal:
[0 * 2^9 + 1 * 2^8 + 0 * 2^7 + 1 * 2^6 + 1 * 2^5 + 0 * 2^4 + 0 * 2^3] + [1 * 2^2 + 0 * 2^1 + 1 * 2^0] =
2^3 * [0 * 2^6 + 1 * 2^5 + 0 * 2^4 + 1 * 2^3 + 1 * 2^2 + 0 * 2^1 + 0 * 2^0] + [1 * 2^2 + 0 * 2^1 + 1 * 2^0] =
8 * 44 + 5 = 
357

With a little bit of math, a Kotlin solution can almost fit on a single line! Let’s see how.

Converting boarding pass to seat ID

We only need to replace B/F and R/L with 1/0 notation, and then convert the resulting binary representation to an integer. Each of these operations is one function call:

fun String.toSeatID(): Int = this
   .replace('B', '1').replace('F', '0')
   .replace('R', '1').replace('L', '0')
   .toInt(radix = 2)

fun main() {
   println("0101100101".toInt(radix = 2)) // 357
   println("FBFBBFFRLR".toSeatID())       // 357
}

The String.replace(oldChar: Char, newChar: Char) function replaces all occurrences of the old character with the new character. There are two more similar functions. If you need to replace each substring with a new string, pass the strings as arguments:

String.replace(oldValue: String, newValue: String)

In order to replace each substring that matches the given regular expression, use another function taking Regex as an argument:

String.replace(regex: Regex, replacement: String)

The String.toInt(radix: Int) function parses the string receiver as an integer in the specified radix. In our case, we specify that the radix is two, so it parses the binary representation of the number.

There’s no need to reimplement the conversion algorithm from scratch when you can use the library functions – unless you specifically want to practice that, of course, but that’s not the goal of this puzzle.

We’ve got the seat ID from the boarding pass now and we can continue with the task.

Finding the maximum seat ID

As usual, we need to read the input first. After implementing the conversion function, it’s quite straightforward:

fun main() {
   val seatIDs = File("src/day05/input.txt")
       .readLines()
       .map(String::toSeatID)
   // ...
}

The seatIDs list is a list of integers, and the only thing left is finding the maximum in this list. There’s no need to implement it from scratch; we simply use the maxOrNull() library function:

fun main() {
    val seatIDs = …

    val maxID = seatIDs.maxOrNull()
    println("Max seat ID: $maxID")
}

We’ve found the seat with the maximum seat ID.

Finding the vacant seat ID

The second part of the task is finding the vacant seat that is missing from the list. There’s guaranteed to be only one. However, we remember that some of the seats at the very front and back of the plane don't exist on this aircraft, so they are missing as well. And so, we can’t simply iterate through the range from 1 to maxID and check for missing seats, as we would also “find” those at the very front and back.

Note, however, that our required vacant seat is not on the edge. This means it’s the only missing seat whose neighbors are both present in the list. So, we can check for this condition: that the seat itself must be missing (in other words, not occupied), but both its neighbors must be occupied.

First, to make our code more expressive, let’s add a function that checks whether a given seat is occupied. It checks that the given seat index belongs to the list of seat IDs provided as the input for our challenge. To make this check quickly, we convert the given list to a set:

fun main() {
    val seatIDs: List<Int> = …
    val occupiedSeatsSet = seatIDs.toSet()
    fun isOccupied(seat: Int) = seat in occupiedSeatsSet
}

Kotlin allows us to create local functions, that is, functions inside other functions. That’s really convenient for the kind of short and simple function we need to write here: the isOccupied() function will capture the outer variable, occupiedSeatsSet, and we don’t need to pass it explicitly as a parameter.

Now the only thing left to do is find the desired seat index, when the seat is not occupied but the neighboring seats (with indices -1 and +1) are both occupied:

val mySeat = (1..maxID).find { index ->
   !isOccupied(index) && isOccupied(index - 1) && isOccupied(index + 1)
}
println("My seat ID: $mySeat")

That’s it!

The whole main function that solves both parts of the task looks as follows:

fun main() {
   val seatIDs = File("src/day05/input.txt")
       .readLines()
       .map(String::toSeatID)
   val maxID = seatIDs.maxOrNull()!!
   println("Max seat ID: $maxID")

   val occupiedSeatsSet = seatIDs.toSet()
   fun isOccupied(seat: Int) = seat in occupiedSeatsSet
   val mySeat = (1..maxID).find { index ->
       !isOccupied(index) && isOccupied(index - 1) && isOccupied(index + 1)
   }
   println("My seat ID: $mySeat")
}

Note that in order to use maxID as the upper bound of the range, we call !!, since the maxOrNull() function returns a nullable value. Specifically, it returns null if the list is empty.

Following the Kotlin philosophy, you might expect to find the max() function, throwing an exception if the list is empty. And you’d be right! However, in Kotlin 1.5 the max() function is deprecated, and in future versions it will be totally removed and replaced with a function throwing an exception. The max() function was present in the standard library starting with Kotlin 1.0 but returned a nullable value, and now the Kotlin team is slowly fixing this small discrepancy. Until the max() function reappears in the standard library, it’s fine to write maxOrNull()!! to explicitly highlight that you need the non-null value as a result, and you prefer an exception if the list is empty. Alternatively, to avoid using !!, you can use maxOf { it } for now.

That’s it! We outlined the strategy for solving the puzzle, recognized the binary encoding for the numbers, discussed how it works, and presented the solution in Kotlin, which is quite simple thanks to the Kotlin standard library functions.

*Used with the permission of Advent of Code (Eric Wastl).

Idiomatic Kotlin: Solving Advent of Code Puzzles, Passport Validation

Sebastian Aigner — Wed, 01 Sep 2021 14:52:59 +0000

Today in “Idiomatic Kotlin”, we’re looking at day 4 of the Advent of Code 2020 challenges, in which we tackle a problem that feels as old as programming itself: input sanitization and validation.

Day 4. Passport processing

We need to build a passport scanner that, given a batch of input text, can count how many passports are valid. You can find the complete task description at https://adventofcode.com/2020/day/4.

Like many challenges, we first inspect our input:

ecl:gry pid:860033327 eyr:2020 hcl:#fffffd
byr:1937 iyr:2017 cid:147 hgt:183cm

iyr:2013 ecl:amb cid:350 eyr:2023 pid:028048884
hcl:#cfa07d byr:1929

hcl:#ae17e1 iyr:2013
eyr:2024
ecl:brn pid:760753108 byr:1931
hgt:179cm

The input is a batch of travel documents in a text file, separated by blank lines. Each passport is represented as a sequence of key-colon-value pairs separated by spaces or newlines. Our challenge is finding out how many passports are valid. For part one, “valid” means that they need to have all the required fields outlined by the security personnel: byr, iyr, eyr, hgt, hcl, ecl and pid (we conveniently ignore their request to validate the cid field).

Solving Day 4, Part 1

Like many challenges, we start by reading our puzzle input as text and trim off any extraneous whitespace at the beginning and the end of the file. As per the description, passports are always separated by blank lines. A blank line is just two “returns”, or newlines, in a row, so we’ll use this to split our input string into the individual passports:

val passports = File("src/day04/input.txt")
    .readText()
    .trim()
    .split("\n\n", "\r\n\r\n")

(Note that depending on your operating system, the line separator in text files is different: On Windows, it is \r\n, on Linux and macOS, it’s \n. Kotlin’s split method takes an arbitrary number of delimiters, allowing us to cover both cases directly.)

We now have a list of passport strings. However, working with lists of raw strings can quickly get confusing. Let’s use Kotlin’s expressive type system to improve the situation and encapsulate the string in a very basic Passport class.

class Passport(private val text: String) {

}

We then just map the results of our split-up input to Passport objects:

// . . .
.map { Passport(it) }

From the problem description, we remember that key-value pairs are either separated by spaces or newlines within a single passport. Therefore, to get the individual pairs, we once again split our input. The delimiters, in this case, are either a space or one of the newline sequences.

fun hasAllRequiredFields(): Boolean {
    val fieldsWithValues = text.split(" ", "\n", "\r\n")
}

We then extract the key from each passport entry. We can do so by mapping our combined fieldsWithValues to only the substring that comes before the colon:

fun hasAllRequiredFields(): Boolean {
    val fieldsWithValues = text.split(" ", "\n", "\r\n")
    val fieldNames = fieldsWithValues.map { it.substringBefore(":") }
    return fieldNames.containsAll(requiredFields)
}

The result of our function will be whether the fieldNames we extracted contain all required fields. The requiredFields collection can be taken directly from the problem statement and translated into a list:

private val requiredFields = listOf("byr", "iyr", "eyr", "hgt", "hcl", "ecl", "pid" /*"cid"*/)

To calculate our final number, and get our first gold star for the challenge, we need to count the passports for which our function hasAllRequiredFields returns true:

fun main() {
    println(passports.count(Passport::hasAllRequiredFields))
}

With that, we have successfully solved the first part of the challenge and can set our sights on the next star in our journey.

Find the full code for the first part of the challenge on GitHub.

Solving Day 4, Part 2

In part two of the challenge, we also need to ensure that each field on the passport contains a valid value. We are given an additional list of rules to accomplish this task, which you can again find in the problem description. Years need to fall into specific ranges, as does a person's height depending on the unit of measurement. Colors need to come from a prespecified list or follow certain patterns, and numbers must be correctly formatted.

A refactoring excursion

Before we start building the solution for part 2, let’s briefly reflect on our code and find possible changes that will make adding this functionality easier for us. At this point in the challenge, we know that our Passport class will need access to the different field names and their associated values. The classical data structure to store such kind of associative-dictionary information is a map. Let’s refactor our code to store passport information in a map instead of a string.

Because turning an input string into a map is still a process that’s associated with the Passport, I like encapsulating such logic in a companion object “factory” function. In this case, we can aptly call it fromString:

companion object {
    fun fromString(s: String): Passport {

The implementation for fromString partially reuses the normalization logic we had previously used in the first part of this challenge and expands it to create a map directly via Kotlin’s associate function:

fun fromString(s: String): Passport {
    val fieldsAndValues = s.split(" ", "\n", "\r\n")
    val map = fieldsAndValues.associate {
        val (key, value) = it.split(":")
        key to value
    }
    return Passport(map)
}

A Passport object now encapsulates a map of string keys and string values:

class Passport(private val map: Map<String, String>) {

Interestingly enough, this change makes the implementation of the first part of our challenge trivial. We can simply check that the key set of our map contains all required fields:

fun hasAllRequiredFields() = map.keys.containsAll(requiredFields)

Returning to solving part 2

For the second part of the challenge, we consider a passport valid if it contains all the required fields and has values that correspond to the official rules.

To ensure that all fields have valid values, we can use the all function to assert that a predicate holds true for every single key-value pair in our map:

fun hasValidValues(): Boolean =
    map.all { (key, value) ->

We can distinguish the different types of fields using a when expression. In this first step, we distinguish the different cases based on the keys in our map:

when (key) {

Each key we know gets a branch in this when statement. They all need to return a boolean value – true if the field is okay, false if the field violates the rules. The surrounding all predicate will then use those results to determine whether the passport as a whole is valid.

The byr (Birth Year), iyr (Issue Year), and eyr (Expiration Year) fields all require their value to be a 4-digit number falling into a particular range:

"byr" -> value.length == 4 && value.toIntOrNull() in 1920..2002
"iyr" -> value.length == 4 && value.toIntOrNull() in 2010..2020
"eyr" -> value.length == 4 && value.toIntOrNull() in 2020..2030

Note that our combined use of toIntOrNull together with the infix function in allows us to discard any non-numeric values, and ensure that they fall in the correct range.

We can apply a very similar rule to the pid (Passport ID) field. We ensure that the length of the value is correct and ensure that all characters belong to the set of digits:

"pid" -> value.length == 9 && value.all(Char::isDigit)

Validating ecl (eye color) just requires us to check whether the input is in a certain set of values, similar to the first part of our challenge:

"ecl" -> value in setOf("amb", "blu", "brn", "gry", "grn", "hzl", "oth")

At this point, we have two more fields to validate: hgt (Height) and hcl (Hair Color). Both of them are a bit more tricky. Let’s look at the hgt field first.

The hgt (Height) field can contain a measurement either in centimeters or inches. Depending on the unit used, different values are allowed. Thankfully, both “cm” and “in” are two-character suffixes. This means we can again use Kotlin’s when function, grab the last two characters in the field value and differentiate the validation logic for centimeters and inches. Like our other number-validation logic, we parse the integer and check whether it belongs to a specific range. To do so, we also remove the unit suffix:

"hgt" -> when (value.takeLast(2)) {
    "cm" -> value.removeSuffix("cm").toIntOrNull() in 150..193
    "in" -> value.removeSuffix("in").toIntOrNull() in 59..76
    else -> false
}

The last field to validate is hcl (Hair Color), which expects a # followed by exactly six hexadecimal digits – digits from 0 through 9, and a through f. While Kotlin can parse base-16 numbers, we can use this case to show off the sledgehammer method for validating patterns – regular expressions. Those can be defined as Kotlin strings and converted using the toRegex function. Triple-quoted strings can help with escape characters:

"hcl" -> value matches """#[0-9a-f]{6}""".toRegex()

Our hand-crafted pattern matches exactly one hashtag, then six characters from the group of 0 through 9, a through f.

As a short aside for performance enthusiasts: toRegex is a relatively expensive function, so it may be worth moving this function call into a constant. The same also applies to the set used in the validation for ecl – currently, it is initialized on each test.

Because the whole when-block is used as an expression, we need to ensure that all possible branches are covered. In our case, that just means adding an else branch, which simply returns true – just because a passport has a field we don’t know about doesn’t mean it can’t still be valid.

else -> true

With that, we have covered every rule outlined to us by the problem statement. To get our reward, we can now just count the passports that contain all required fields and have valid values:

fun partTwo() {
    println(passports.count { it.hasAllRequiredFields() && it.hasValidValues() })
}

We end up with a resulting number, which we can exchange for the second star. We’re clear for boarding our virtual flight. Though this was probably not the last challenge that awaits us…

Find the complete solution for the second part of the challenge on GitHub.

Conclusion

For today’s challenge, we came up with an elegant solution to validate specific string information, which we extracted using utility functions offered by the Kotlin standard library. As the challenge continued, we reflected on our code, identified more fitting data structures, and changed our logic to accommodate it. Using Kotlin’s when statement, we were able to keep the validation logic concise and all in one place. We saw multiple different ways of how to validate input – working with ranges, checking set membership, or matching a particular regular expression, for example.

Many real-world applications have similar requirements for input validation. Hopefully, some of the tips and tricks you’ve seen in the context of this little challenge will also be helpful when you need to write some validation logic on your own.

To continue puzzling yourself, check out adventofcode.com, whose organizers kindly permitted us to use their problem statements for this series.

If you want to see more solutions for Advent of Code challenges in the form of videos, subscribe to our YouTube channel and hit the bell to get notified when we continue our idiomatic journey. More puzzle solutions are coming your way!

Idiomatic Kotlin: Solving Advent of Code Puzzles, Day 2

Svetlana Isakova — Wed, 21 Jul 2021 16:25:30 +0000

Idiomatic Kotlin: Solving Advent of Code Puzzles, Day 2

Let’s continue learning how to write idiomatic Kotlin code by solving the AdventOfCode tasks! Today, we’re discussing the solution for the day 2 task.

Day 2. Password philosophy

We need to confirm that passwords meet the corporate policy. Find the full task description at https://adventofcode.com/2020/day/2*.

First, we need to read the input:

1-3 a: abcde
1-3 b: cdefg
2-9 c: ccccccccc

Each line contains the password policy and the password. Our task is to check that the password is valid and conforms to the given policy. The policies are different in the first and the second parts of the task.

In the first part, the password policy indicates the lowest and highest number of times a given letter must appear for the password to be valid. For example, 1-3 a means that the password must contain a at least once and at most 3 times. In the example, two passwords, the first and the third ones, are valid. The first contains one a, and the third contains nine cs, both within the limits of their respective policies. The second password, cdefg, is invalid, as it contains no instances of b but needs at least 1.

In the second part, the policy describes two positions in the password, where 1 means the first character, 2 means the second character, and so on (indexing starts at 1, not 0). Exactly one of these positions must contain the given letter. Other occurrences of the letter are irrelevant. Given the same example list from above:

1-3 a: abcde is valid: position 1 contains a and position 3 does not.
1-3 b: cdefg is invalid: neither position 1 nor position 3 contains b.
2-9 c: ccccccccc is invalid: both positions 2 and position 9 contain c.

We should count the number of passwords from the given input that are valid according to the interpretations of the policies.

As usual, if you haven’t done it, please solve the task yourself first. Here’s how you can set up Kotlin for this purpose.

Solution

First, we should read and parse the input. Let’s create a data class for storing a given password together with its policy:

data class PasswordWithPolicy(
   val password: String,
   val range: IntRange,
   val letter: Char
)

Each policy specifies an integer range and a letter that we store in the IntRange and Char types, accordingly. The modifier data instructs the compiler to generate some useful methods for this class, including the constructor, equals, hashCode, and toString.

Parsing input

Let’s write a function that parses one input line into this class. Since it’s a function that creates an instance, let’s put it into a companion object in our data class. Then we can call it by the class name: PasswordWithPolicy.parse().

data class PasswordWithPolicy(...) {
   companion object {
       fun parse(line: String): PasswordWithPolicy { 
           TODO()
       }
   }
}

While developing, you can put the TODO() call that throws the NotImplementedErrorexception. Because it returns the Nothing type, which is a subtype of any other type, the compiler won’t complain. The function is supposed to return PasswordWithPolicy, but throwing an exception inside is totally valid from the compiler’s point of view.

There are two ways to parse the input: by using utility functions on Strings or by using regular expressions. Let’s discuss both of these ways.

The Kotlin standard library contains many useful functions on Strings, including substringAfter() and substringBefore() which perfectly solve the task in our case:

// 1-3 a: abcde
fun parse(line: String) = PasswordWithPolicy(
   password = line.substringAfter(": "),
   letter = line.substringAfter(" ").substringBefore(":").single(),
   range = line.substringBefore(" ").let {
       val (start, end) = it.split("-")
       start.toInt()..end.toInt()
   },
)

We provide the parameter names explicitly while calling the PasswordWithPolicy constructor. The input format convention requires that:

password be the string that goes right after the colon
the letter go between the whitespace and the colon, and
the range go before the whitespace and consist of two numbers split by “-”

To build a range, we first take the substring before the whitespace and split it with the “-” delimiter. We then use only the first two parts (start and end), and build a range using the “..” operator converting both lines to Ints. We use let to convert the result of substringBefore() to the desired range.

In this code, we assume that all the input lines follow the rules. In a real-world scenario, we should check that the input is correct. substringAfter() and similar functions take a second argument default to the string itself that should be returned in the event the given delimiter is not found. toInt() and single() have toIntOrNull() and singleOrNull() counterparts returning null if the string can’t be converted to an integer number or consists of more than one character.

Let’s now implement the same logic using regular expressions. Here is a regular expression describing the input format:

(\d+)-(\d+) ([a-z]): ([a-z]+)

First are two numbers split by -, then a letter and a password.

Our new parse function matches the line against a regular expression and then builds PasswordWithPolicy on the result:

private val regex = Regex("""(\d+)-(\d+) ([a-z]): ([a-z]+)""")
fun parseUsingRegex(line: String): PasswordWithPolicy =
   regex.matchEntire(line)!!
       .destructured
       .let { (start, end, letter, password) ->
           PasswordWithPolicy(password, start.toInt()..end.toInt(), letter.single())
       }

In Kotlin, you use the Regex class to define a regular expression. Note how we put it inside a triple-quoted string, so you don’t need to escape “\”. For regular strings, escaping is done in the conventional way, with a backslash, so if you need a backslash character in the string, you repeat it: "(\\d+)-(\\d+)".

We assume that our input is correct, which is why we use “!!” to throw an NPE if the input doesn’t correspond to the regular expression. An alternative is to use the safe access “?.” here and return null as the result.

The destructured property provides components for a destructuring assignment for groups defined in the regular expression. We use its result together with let and destruct it inside the lambda expression, defining start, end, letter, and password as parameters. As before, we need to convert strings to Ints and Char.

Password validation

After we read the input, we need to validate whether the passwords comply with the given policy.

In the first part, we need to ensure that the number of occurrences of a given letter is in a range. It’s one line in Kotlin:

data class PasswordWithPolicy(
   val password: String,
   val range: IntRange,
   val letter: Char
) {
   fun validatePartOne() =
       password.count { it == letter } in range
       ... 
}

We count the occurrences of letter in the password string, and check that the result is in range. in checks that the given element belongs to a range. For numbers and other comparable elements, x in range is the same as writing explicitly range.first <= x && x <= range.last.

The second part isn’t difficult. We need to check that exactly one of the positions (stored in the range) contains the given letter. We use the boolean xor operator for that, which returns true if the operands are different. That’s exactly what we need here:

fun validatePartTwo() =
   (password[range.first - 1] == letter) xor (password[range.last - 1] == letter)

We need to subtract 1 from first and last because they imply indexing from one, but string indexation starts from zero.

Added all together, this gives us our main function that finds the result for both parts:

fun main() {
   val passwords = File("src/day2/input.txt")
       .readLines()
       .map(PasswordWithPolicy::parse)
   println(passwords.count { it.validatePartOne() })
   println(passwords.count { it.validatePartTwo() })
}

Note how we pass a member reference PasswordWithPolicy::parse to the map function to convert the strings to passwords.

That’s it! We discussed how to solve this problem, and along the way, looked at string utility functions, regular expressions, operations on collections, and how let helps transform the expression nicely to the form you need.

Please let us know if you find this format useful and would like us to provide solutions for more difficult tasks!

*Used with the permission of Advent of Code (Eric Wastl).

Solving Advent of Code Puzzles in Idiomatic Kotlin

Svetlana Isakova — Thu, 15 Jul 2021 12:41:37 +0000

What’s the best way to learn a language other than writing some code with it? Solving fun and short tasks like the ones from Advent of Code might be a great opportunity to practice your language skills, and you can learn a lot if you compare your solutions with how others have solved the same problem.

Lots of developers from around the world, including some from the Kotlin team, take part in the Advent of Code challenges created by Eric Wastl. Advent of Code is a series of tasks published every December, which you solve and compete with others. Many would agree that it’s the best advent calendar to celebrate Christmas and New Year!

To help the community learn idiomatic Kotlin, and motivate more developers to solve Advent of Code tasks in Kotlin in the future, we decided to prepare solutions for the tasks from Advent of Code 2020. It doesn’t matter if you solved it back in December, you’re ready to solve it now, or you just want to check the solutions – we hope you’ll find something useful in these materials. Of course, it works best if you try to solve the same task first yourself!

Below is the solution and video for the first task. If you find this format useful and want us to cover more tasks in a similar fashion, please share in the comments!

Day 1. Report Repair

We’re fixing an expense report! Find the full task description at https://adventofcode.com/2020/day/1*.

You need to find the two (and in the second part, three) entries from the list of numbers that sum to 2020 and then multiply those two (or three) numbers together.

How to solve the task

Register at https://adventofcode.com/, open the task at https://adventofcode.com/2020/day/1, write your solution in Kotlin, and check the result on the site. You can either write Kotlin code online or using an IDE:

download the free Community Edition of IntelliJ IDEA
create a Kotlin project
write your solution there

Finally, compare your solution with the solution below.

We marked the src folder as a source set to put the code directly there. We copied input files, like src/day1/input.txt, to the source folder for convenience. You can find the solutions in this project.

Solution

Here’s the sample input:

First, we need to read and parse the input. We can use the Kotlin readLines() function for reading a list of lines from a given file:

File("src/day1/input.txt").readLines()

The readLines() returns a list of Strings, and we convert it to a list of numbers:

import java.io.File
fun main() {
   val numbers = File("src/day1/input.txt")
       .readLines()
       .map(String::toInt)


}

You put this code inside the main function, the entry point for your program. When you start typing, IntelliJ IDEA imports the java.io.File automatically.

Now we can simply iterate through the list, and then for each number repeat the iteration and check the sum:

for (first in numbers) {
   for (second in numbers) {
       if (first + second == 2020) {
           println(first * second)
           return
       }
   }
}

You put this code inside main, so return returns from main when the required numbers are found.

In a similar way, you check the sum of three numbers:

for (first in numbers) {
   for (second in numbers) {
       for (third in numbers) {
           if (first + second + third == 2020) {
               println(first * second * third)
               return
           }
       }
   }
}

You can run it and get the result for a given input. That’s it! The first task is really a simple one.

However, we iterate over the same list again and again for each of the elements. Having two nested loops for finding two numbers makes it N² operations, where N is the number of elements. When we need to find three numbers, that’s three nested loops, and N³ operations. If the list of numbers is large, that’s not the most efficient way to solve this type of problem. Surely there is a better way, right?

There definitely is and the Kotlin standard library can help us express that concisely. As often happens, we can replace the long calculation with some kind of smart storage used to find the result.

Solving the task for two numbers

First, let’s build a map for number “complements” – numbers that together with the given number sum up to 2020:

val complements = numbers.associateBy { 2020 - it }

We use the Kotlin associateBy function to build the map. Its lambda argument returns a key in this map, by which the list element is getting stored. For the sample input it’ll be the following map:

numbers: [1721, 979, 366, 299, 675, 1456]
complements map: {299=1721, 1041=979, 1654=366, 1721=299, 1345=675, 564=1456}

After this procedure, you can clearly see the answer! The very first number 1721 from the list is present in the complements map as a key: 1721=299, which means it’s the complement for the number 299, and they sum to 2020.

Having stored this information in a map, we can check if any number from the list has a complement in this map. The following code finds the first number with an existing complement:

val pair = numbers.mapNotNull { number ->
   val complement = complements[number]
   if (complement != null) Pair(number, complement) else null
}.firstOrNull()

We transform each number into a pair consisting of the number and its complement (if the complement exists) and then find the first non-null result.

We use mapNotNull, which transforms each element in a list and filters out all the resulting nulls. It’s shorthand for calling first map, and then filterNotNull on the result.

firstOrNull returns the first element in the list or null if the list is empty. Kotlin standard library often uses the OrNull suffix to mark functions returning null on failure rather than throwing an exception (like elementAtOrNull, singleOrNull, or maxOrNull).

Starting with Kotlin 1.5.0, you can also replace the two consequent operations mapNotNull and first(OrNull) with one function call: firstNotNullOf(OrNull).

After building the auxiliary structure, we managed to find the resulting two numbers in N operations, not in N² as before!

We need a multiplication of these numbers, so here’s the last step:

println(pair?.let { (a, b) -> a * b })

The pair variable contains a nullable Pair of two numbers and is null if the initial list contains no numbers that sum up to 2020. We use safe access ?. together with the let function and destructuring in a lambda syntax to display the result in case pair is not null.

Solving the task for three numbers

The next step is solving this problem for three numbers. Let’s reuse what we’ve done so far and extract the logic of finding a pair of numbers summing up to a given number into a separate function:

fun List<Int>.findPairOfSum(sum: Int): Pair<Int, Int>? {
   // Map: sum - x -> x
   val complements = associateBy { sum - it }
   return firstNotNullOfOrNull { number ->
       val complement = complements[number]
       if (complement != null) Pair(number, complement) else null
   }
}

We also used the firstNotNullOfOrNull function.

Now, we use findPairOfSum to build a helper map that stores the complement pair of values for each number which together with this number sums up to 2020:

// Map: x -> (y, z) where y + z = 2020 - x
val complementPairs: Map<Int, Pair<Int, Int>?> =
   numbers.associateWith { numbers.findPairOfSum(2020 - it) }

For the same initial input, here’s the complement pairs map:

numbers: [1721, 979, 366, 299, 675, 1456]
complement pairs: {1721=null, 979=(366, 675), 366=(979, 675), 299=null, 675=(979, 366), 1456=null}

As before, you already can see the answer! It’s the number that corresponds to a non-null pair in a map.

However, we don’t really need to build the whole map — we only need to find the first number that corresponds to a non-null pair! Let’s find it using the already familiar firstNotNullOfOrNull function:

fun List<Int>.findTripleOfSum(): Triple<Int, Int, Int>? =
   firstNotNullOfOrNull { x ->
       findPairOfSum(2020 - x)?.let { pair ->
           Triple(x, pair.first, pair.second)
       }
   }

Note Kotlin’s concise syntax – the function can return an expression directly.

The final step is to find the multiplication if the resulting triple is non-null, similar to how we did it before:

println(triple?.let { (x, y, z) -> x * y * z} )

That’s all!

In the next part, we’ll discuss how to solve the second task. Please let us know if you find this content useful and would like us to provide solutions for more tasks!

*Used with the permission of Advent of Code (Eric Wastl).

Exploring Kotlin Lists in 2021

Sebastian Aigner — Thu, 08 Jul 2021 14:46:58 +0000

This blog post accompanies a video from our YouTube series which you can find on our Kotlin YouTube channel, or watch here directly!

Today, we're talking all about lists! Lists are the most popular collection type in Kotlin for a good reason, and we’ll find out why together.

Lists

What’s a list?

If you've written Kotlin code before, you've definitely seen a list – they're collections of ordered elements, where each element is accessible via an index. As such, they're one of the basic building blocks for a lot of Kotlin code.

Creating lists

If you’re creating lists on your own, you’re most likely using the listOf function, which takes a variable number of arguments, and those become the elements of your list. Even in this blog post series, we've created a list like that about a hundred times:

listOf(1, 2, 3, 4, 5)
// [1, 2, 3, 4, 5]

A little lesser known is the ability to create lists via the List constructor function. Here, we pass two parameters – the size of the list, and an init function that creates each of the elements in our list. That function we pass gets the element index as its parameter, which we can use to adjust the item content:

List(5) { idx -> "No. $idx" }
// [No. 0, No. 1, No. 2, No. 3, No. 4]

Of course, lists can come from other places as well: types like collections, iterables, and others often feature a toList method.

For example, in the case of a string, we get a list of its characters:

"word-salad".toList()
// [w, o, r, d, -, s, a, l, a, d]

Given a map of placements and the associated medals, we can call toList on that to get a list of key-value pairs:

mapOf(
    1 to "Gold",
    2 to "Silver",
    3 to "Bronze"
).toList()
// [(1, Gold), (2, Silver), (3, Bronze)]

Sequences, ranges, and progressions behave similarly. They materialize their values, and put them in a list when calling toList. As an example, we can consider a random sequence of numbers, or the inclusive integer range from zero to ten:

generateSequence {
    Random.nextInt(100).takeIf { it > 30 }
}.toList()
// [73, 77, 69, 79, 71, 64]

(0..10).toList()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

An extra case worth mentioning is calling toList on something that already is a list. This creates brand-new copy of the original list. We can see this in the following example, where we create a mutable list with a few numbers. By calling toList, we obtain a new working copy:

val list = mutableListOf(1, 2, 3)
val otherList = list.toList()

list[0] = 5
println(list)
// [5, 2, 3]

println(otherList)
// [1, 2, 3]

As we can see, when the original list is changed, the working copy we just created does not contain any of the changes applied to the original collection.

Accessing list items

To get items out of our lists, we have multiple options. The most basic way of doing so is using the get function, together with an index:

val myList = listOf("🍔", "🌭", "🍕")
myList.get(1) // 🌭

But if you ever type out .get manually, you’ll see that IntelliJ IDEA already gives you the helpful hint to use some much more popular syntactic sugar for it – the indexed access operator, denoted by the brackets with an index:

myList[1] // 🌭

There are also some additional flavors of the get function which we can explore. Two of those that come to mind are getOrElse and getOrNull. They help us handle cases where we might be accessing an index that falls out of bounds (which can either be a negative index, or an index that’s larger than the last index in our collection.)

Using the default indexed access causes an exception when provided a parameter that's out of bounds:

myList[3]
// Index 3 out of bounds for length 3

We can use getOrNull to short-circuit our return value to null. Alternatively, we can use getOrElse to compute a default value to be used instead. The default value is computed based on a passed lambda, which also receives the index:

val myList = listOf("🍔", "🌭", "🍕")
myList.getOrNull(3)
// null

myList.getOrElse(3) {
    println("There's no index $it!")
    "😔"
}
// There's no index 3!
// 😔

These special functions are only necessary to work with indexes that might fall out of bounds, though. Nullability, for example, is handled the same way as you would in any other situation in Kotlin: using the power of the Elvis operator, smart-casts and friends.

val listOfNullableItems = listOf(1, 2, null, 4)
val x: Int = listOfNullableItems[0] ?: 0

Slicing

Of course, we can go beyond getting individual items out of our list. Because a list is a collection like any other, we have access to the same take and drop functions that were introduced in the Diving into Kotlin collections post.

But lists have a special way of retrieving multiple items - the slice function!

When we give this function a bunch of indexes, it returns the elements at those places in our collection. In this example, we’re passing a list with index 0, 2, 4, and get those items from our list of letters:

val myList = listOf("a", "b", "c", "d", "e")
myList.slice(listOf(0, 2, 4))
// [a, c, e]

Instead of writing out all the indices by hand, we could also use IntRanges or progressions to specify the indexes. For example, we could request “all items from 0 through 3”, or specify a custom step-size of 2. We could even pull out some items in reverse order, if we create a progression that uses downTo:

myList.slice(0..3)
// [a, b, c, d]

myList.slice(0..myList.lastIndex step 2)
// [a, c, e]

myList.slice(2 downTo 0)
// [c, b, a]

As you may suspect, this list of list features is not quite exhaustive – as always, there’s some more to explore even on this subject. But let’s put that on the back burner for a bit, and move on to a special kind of list – it's time to talk about mutable lists!

Mutable Lists

What's so special about mutable lists? Well, you can mutate them! That, of course, doesn’t mean that these lists will turn into zombies (🧟‍♂️), but that you can change their content. If we consult an excerpt of a class hierarchy, we can see that MutableList specializes List, meaning everything we’ve learned about lists so far also works for their mutable counterpart, plus some extra functionality.

It's precisely that extra functionality that we’re interested in right now!

Creating mutable lists

Once again, mutable lists are commonly created via the mutableListOf function, with a bunch of values as arguments. And, wherever you were able to find a toList method, as discussed previously, you’ll probably also find a toMutableList. That also includes other lists and mutable lists – where you’ll get a fresh copy when calling toMutableList:

mutableListOf(1, 2, 3)
// [1, 2, 3]

(0..10).toMutableList()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

listOf(1, 2, 3).toMutableList()
// [1, 2, 3]

Add / Remove / Update

Let's move on to the core of this subject – the ability to change content. That starts with adding something to the collection. If we want to add an extra number to the end of our mutable list we can do so via the add function, or by using the += operator shorthand, both of which append an item to the end of the list.

If we know where in the collection we want our item to go, the add function also accepts an index, which inserts the new element at that position and moves the surrounding elements to accommodate it. In the same way, we can also add a whole other collection to our mutable list:

val m = mutableListOf(1, 2, 3)
m.add(4)
m += 4
println(m)
// [1, 2, 3, 4, 4]

m.add(2, 10)
println(m)
// [1, 2, 10, 3, 4, 4]

m += listOf(5, 6, 7)
println(m)
// [1, 2, 10, 3, 4, 4, 5, 6, 7]

We’re of course not constrained to just adding elements to our list – we can also remove them. If we know what element we want to get rid of, we can do that via the remove function or the -= operator shorthand, which removes from our collection a single instance of the element we provide. In this example, after calling -= and remove, we got rid of two of the 3s in our original collection – because each invocation removed one of them.

Alternatively, we can also pass the -= operator a collection of elements. In this case, the operator acts as a shorthand for the removeAll function. Here, it looks at every element in the collection we pass, and removes all instances of them in our original, mutable collection. (This is an important distinction to make!) So, by passing 1 and 4 as a collection, we remove all instances of those numbers from our mutable list, and we’re left with only 2 and 3 at the end.

val m = mutableListOf(1, 2, 3, 3, 3, 4, 4, 4)
m -= 3
m.remove(3)
println(m)
// [1, 2, 3, 4, 4, 4]

m -= listOf(1, 4)
println(m)
// [2, 3]

If we know the index where we want to kick an item out, we use the removeAt function instead. For example, we could remove the second element in our list, which resides at index 1.

val m = mutableListOf(1, 2, 3, 3, 3)
m.removeAt(1)
println(m)
// [1, 3, 3, 3]

To update an item, we most commonly use the indexed access operator – so the brackets – together with an assignment. That one calls the set function with that index and element under the hood, and switches out the item at the specified index – in this case, trading a "b" for an "a".

val m = mutableListOf("a", "b", "c", "d", "e")
m[1] = "a"
println(m)
// [a, a, c, d, e]

Fill and Clear

In certain situations, we might want to turn all elements of our list into the same element – like zeroing out a buffer before reusing it. This is something we can do using the fill function, which replaces each element with the same value we specify. If we look at a list of fruits, for example, and suddenly realize that all of them are really just sugar, we use fill to replace them with candy (🍬). While that metaphor may not be entirely scientifically accurate, it's tasty nonetheless!

And when we want to wipe our collection clean, the clear function can help with removing all elements from a collection – in our case, getting rid of all the candy:

val fruits = mutableListOf("🍉", "🍊", "🥝")
// wait, it's all sugar?
fruits.fill("🍬")

println(fruits)
// [🍬, 🍬, 🍬]

// ... nom nom
fruits.clear()

println(fruits)
// []

Perhaps unsurprisingly, mutable lists grow and shrink automatically to accommodate all your items, so you can have an arbitrary number of elements in your collection. This might be obvious, but it’s so darn convenient, so I figured I’d mention it. The things we take for granted!

In-place modifications

Thinking back to some of the previous entries of this series, we’ve seen a number of neat functions which we wouldn’t want to miss for mutable collections either – things like sorted, shuffled, and reversed. However, those don’t modify the original collection.

Luckily for us, these functions also have a mutable counterpart. So, when we want to sort, shuffle, or reverse a mutable list in place – instead of creating a new, separate copy with the effects applied – we use the sort() instead of sorted(), shuffle() instead of shuffled(), and reverse() instead of reversed() functions:

val list = listOf(3, 1, 4, 1, 5, 9)
list.shuffled()
list.sorted()
list.reversed()

println(list)
// [3, 1, 4, 1, 5, 9]

val m = list.toMutableList()
m.shuffle()
println(m)
// [5, 1, 1, 3, 4, 9]

m.sort()
println(m)
// [1, 1, 3, 4, 5, 9]

m.reverse()
println(m)
// [9, 5, 4, 3, 1, 1]

Mutable lists also offer the possibility to remove or keep all elements that fulfill a certain predicate. The removeAll function can remove all elements that match the predicate we specify. Let’s say we’re not a fan of small numbers in our collection, and only want to keep numbers that are 5 or above – removeAll helps us do exactly that.

val numbers = mutableListOf(3, 1, 4, 1, 5, 9)
numbers.removeAll { it < 5 }
println(numbers)
// [5, 9]

The retainAll function is the opposite, and only keeps those elements in the mutable list that match. If we want to retain every character in our collection that is a letter, we do that with the retainAll function:

val letters = mutableListOf('a', 'b', '3', 'd', '5')
letters.retainAll { it.isLetter() }
println(letters)
// [a, b, d]

This might feel a bit familiar to you, and rightfully so, because these are essentially the mutating equivalents of the filter and filterNot functions.

Views on Lists

The last topic on today’s agenda is views on lists. That name already hints at what they allow us to do – they allow us to look at the elements in our list from a different perspective – let’s see what that means.

Let’s assume we have a collection of fruits. To create a view, we can use the subList function, which takes a beginning and end index, which determines which elements should be “visible” in the view. By having a look at an example sublist, we can see that it contains the elements from our original collections based on the indices we specify (with the upper bound being exclusive):

val fruits = mutableListOf("🍉", "🍊", "🥝", "🍏")
val sub = fruits.subList(1, 4)
println(sub)
// [🍊, 🥝, 🍏]

Because this is only a view, and not a copy of our original collection, changes are automatically visible. That means if we change the orange to a banana in the underlying fruits list, then our sublist will reflect that change:

fruits[1] = "🍌"
println(sub)
// [🍌, 🥝, 🍏]

What may be even more interesting is that this sublist is in itself mutable, as well! If we change the green apple in our sublist to a pineapple, and have a look at our original fruits collection again, we see that the change is visible from here as well:

sub[2] = "🍍"
println(fruits)
// [🍉, 🍌, 🥝, 🍍]

Or, we can use the fill function which we’ve learned about earlier to turn an interval inside of our fruit-list back into candy, again:

sub.fill("🍬")
println(fruits)
// [🍉, 🍬, 🍬, 🍬]

To reiterate; all of that works because these aren’t two different collections – there is only one collection, and subList has just given us a different perspective on that list!

An important note on the topic of sublists: They are only well-defined as long as the underlying, original list is not structurally changed. Changes affecting the size of the list, for example, automatically cause any views that were previously returned by invoking subList to have undefined behavior.

For a common case, which is looking at a list backwards, the Kotlin standard library also comes with the asReversed function. It provides a backwards view of the underlying list. Once again, changes made in the view are visible in the original collection, and vice versa. As you can see in the following example, turning the orange into a banana in our original list also changes what we see in the reversed view. Altering it back to a pineapple via our reversed view also alters our original mutable list:

val fruits = mutableListOf("🍉", "🍊", "🥝", "🍏")
val stiurf = fruits.asReversed()

println(stiurf)
// [🍏, 🥝, 🍊, 🍉]

fruits[1] = "🍌"
println(stiurf)
// [🍏, 🥝, 🍌, 🍉]

stiurf[2] = "🍍"
println(fruits)
// [🍉, 🍍, 🥝, 🍏]

These types of “views” are actually available for non-mutable lists, as well, and allow you to pass around different sub-selections of your collections without having to create new copies every time – however, this seemed like a topic that would be nicer to illustrate with the mutable variant, to drive the point home that there really is only one underlying collection.

Outro

With that, we have reached the end of today’s expedition! I hope some of the stuff you’ve seen today is helping you strengthen your understanding of Kotlin lists. When you’re writing Kotlin code the next time, see if you can apply some of the stuff we’ve talked about today – whether it’s slicing a collection, using sub-lists, or handling out-of-bounds situations for lists elegantly with the getOrNull and getOrElse functions.

If you’ve learned something new, and want to see more like this, make sure to follow us here on dev.to, and check out some of the interesting content we publish on our official YouTube channel, as well!

Now, it’s time for all of you to go and explore some more Kotlin! Take care, and see you in the next one!

Advanced Kotlin Collection Functionality

Sebastian Aigner — Mon, 14 Jun 2021 17:49:10 +0000

This blog post accompanies a video from our YouTube series which you can find on our Kotlin YouTube channel, or watch here directly!

Today, we are learning about advanced functions that we can use to work with and manipulate all kinds of Kotlin collections!

Checking predicates: `any`, `none` and `all`

Let’s warm up by having a look at a selection of functions that allow us to check conditions for our collection elements.

They’re called any, none, and all. Each of them takes a predicate – so a function that returns true or false – and checks whether the collection fits this predicate.

Let’s say we have a group of friends (which is really just a List<Person>, each featuring a name, age, and maybe a driversLicense):

data class Person(val name: String, val age: Int, val driversLicense: Boolean = false)

val friendGroup = listOf(
    Person("Jo", 19),
    Person("Mic", 15),
    Person("Hay", 33, true),
    Person("Cal", 25)
)

When we want to check if the group can travel by car, we want to check if any of them have a driver's license – so we use the any function. It returns true if there is at least one element in our collection for which the predicate returns true.

val groupCanTravel = friendGroup.any { it.driversLicense }
// true

As another example, let’s say we want to check if this group of friends is allowed to enter a club – for this, we would need to make sure that none of the folks in the group are underage!

Here, we can use the none function, which only returns true when there is not a single element in our collection that holds true for our predicate:

val groupGetsInClub = friendGroup.none { it.age < 18 }
// false

The third function in the bunch is the all function. At this point, you can probably spot the pattern – all returns true, if each and every element in our collection matches our predicate. We could use it to check whether all names in our friend group are short:

val groupHasShortNames = friendGroup.all { it.name.length < 4 }
// true

Predicates for empty collections

While on the topic, let's have a little brain teaser: How do any, none, and all behave for empty collections?

val nobody = emptyList<Person>()
// what happens here?

Let’s look at any first. There is no element that can satisfy the predicate, so it returns false:

nobody.any { it.driversLicense }
// false

The same goes for none – there is no function that can violate our predicate, so it returns true:

nobody.none { it.age < 18 }
// true

The all function, however, returns true with an empty collection. This may surprise you in the first moment:

nobody.all { it.name.count() < 4 }

But this is quite intentional and sound: You can't name an element that violates the predicate. Therefore, the predicate has to be true for all elements in the collection – even if there are none!

This might feel a bit mind-bending to think about at first, but you’ll find that this concept, which is called the vacuous truth, actually plays very well with checking conditions, and expressing logic in program code.

Collection parts: `chunked` and `windowed`

With our brain freshly teased, let’s move on to the next topic, and learn about how to break collections into parts!

The `chunked` function

If we have a collection that just contains a bunch of items, we can cut up the list into individual chunks of a certain size by using the chunked function. What we get back is a list of lists, where each element is a _chunk _of our original list:

val objects = listOf("🌱", "🚀", "💡", "🐧", "⚙️", "🤖", "📚")
println(objects.chunked(3))
// [[🌱, 🚀, 💡], [🐧, ⚙️, 🤖], [📚]]

In the example above, we break our list of random objects (represented with emojis) apart, using a chunk size of 3.

The first element in our result is in itself a list which contains our first three objects – [🌱, 🚀, 💡].
The second element is once again a chunk, and contains the three elements that follow after that – [🐧, ⚙️, 🤖].
The last element is also a chunk – but since we ran out of elements to fill it with three items, it only contains the book stack - [📚].

In typical standard library fashion, the chunked function also provides a little bit of extra power. To immediately transform the chunks we just created, we can apply a transformation function. For example, we can reverse the order of elements in the resulting lists, without having to do another map call separately:

println(objects.chunked(3) { it.reversed() })
// [[💡, 🚀, 🌱], [🤖, ⚙️, 🐧], [📚]]

To summarize: the chunked function cuts our original collection into lists of lists, where each list has the specified size.

The `windowed` function

Closely related is the windowed function. It also returns a list of lists from our collection. Instead of cutting it up into pieces, however, this function generates a “sliding window” of our collection:

println(objects.windowed(3))
// [[🌱, 🚀, 💡], [🚀, 💡, 🐧], [💡, 🐧, ⚙️], [🐧, ⚙️, 🤖], [⚙️, 🤖, 📚]]

The first window is once again the first three elements – [🌱, 🚀, 💡].
The next window is [🚀, 💡, 🐧] – we simply “moved” our window of size 3 over by one, which includes some overlap.

The windowed function can also be customized. We can change both window and step size, the latter being the number of elements that the window should “slide along” for each step:

println(objects.windowed(4, 2, partialWindows = true))
// [[🌱, 🚀, 💡, 🐧], [💡, 🐧, ⚙️, 🤖], [⚙️, 🤖, 📚], [📚]]

As you can see in the example above, we can also control whether our result should contain partial windows. This changes the behavior when we’ve reached the end of our input collection, and we’re running out of elements.

With partial windows enabled, we just keep sliding, and we get the last elements trickling in, in the form of smaller windows, until we get a window which once again only contains the last element from our input collection – [⚙️, 🤖, 📚], [📚].

windowed also allows us to perform an additional transformation at the end, which can modify the individual windows directly:

println(objects.windowed(4, 2, true) {
    it.reversed()
})
// [[🐧, 💡, 🚀, 🌱], [🤖, ⚙️, 🐧, 💡], [📚, 🤖, ⚙️], [📚]]

Un-nesting Collections: Flatten and Flatmap

The chunked and windowed functions, along with some others all return nested collections – lists of lists. What if we want to un-nest these, turning them back into flat lists of elements? As usual, we do not need to fear, because the standard library has got us covered.

We can call the flatten function on a collection of collections. As you may suspect, the result is a single list of all the elements that were originally contained inside of our nested collections:

val objects = listOf("🌱", "🚀", "💡", "🐧", "⚙️", "🤖", "📚")
objects.windowed(4, 2, true) {
    it.reversed()
}.flatten()
// [🐧, 💡, 🚀, 🌱, 🤖, ⚙️, 🐧, 💡, 📚, 🤖, ⚙️, 📚]

This is also a good point to talk about the flatMap function. flatMap is like a combination of first using map, and then using flatten – It takes a lambda which generates a collection from each of the elements in our input collection:

val lettersInNames = listOf("Lou", "Mel", "Cyn").flatMap {
    it.toList()
}
println(lettersInNames)
// [L, o, u, M, e, l, C, y, n]

In the example above, the function that we provide creates a list for each element in our input collection, containing the letters of the original string. Next, that collection of collections gets flattened. As desired, we end up with a plain list of elements – the list of characters from the names of the original collection.

If you are doing an operation on a list, which in turn generates a collection for each one of the input elements, consider if flatMap can help you simplify your code!

Combining collections: `zip` and `unzip`

So far, we have always looked at a single collection, and what we can do with it. Let's learn about a way to combine two collections, and create a new one from them – it's time to zip!

The `zip` function

Assume we have two collections, where the elements at each index are somehow related. For example, this could be a list of cities in Germany, and we have another list of German license plates that correspond to those cities:

val germanCities = listOf(
    "Aachen",
    "Bielefeld",
    "München"
)

val germanLicensePlates = listOf(
    "AC",
    "BI",
    "M"
)

println(germanCities.zip(germanLicensePlates))
// [(Aachen, AC), (Bielefeld, BI), (München, M)]

As you can see, by zipping these two collections, we get a list of pairs, where each pair contains the elements with the same index from the original two collections.

Metaphorically, this is similar to a zipper on a jacket, where the teeth match up one by one. We zip together the elements of our collection, and we get pairs of each city and its corresponding license plate.

For an extra bit of flair, we can also call the zip function using infix notation:

println(germanCities zip germanLicensePlates)
// [(Aachen, AC), (Bielefeld, BI), (München, M)]

zip can also take a transformation function. We can pass a lambda that receives the values of the individual zipped pairs, and we can apply a transformation:

println(germanCities.zip(germanLicensePlates) { city, plate ->
    city.uppercase() to plate.lowercase()
})
// [(AACHEN, ac), (BIELEFELD, bi), (MÜNCHEN, m)]

The `unzip` function

The standard library also contains the inverse function, called unzip, which takes a list of pairs, and splits them back into a pair of two separate lists:

val citiesToPlates = germanCities.zip(germanLicensePlates) { city, plate ->
    city.uppercase() to plate.lowercase()
}
val (cities, plates) = citiesToPlates.unzip()

println(cities)
// [AACHEN, BIELEFELD, MÜNCHEN]

println(plates)
// [ac, bi, m]

The example above uses a destructuring declaration to easily access both of them.

The `zipWithNext` function

In a way, zipWithNext is really a specialized case of the windowed function we got to know today: Instead instead of zipping together two separate lists element by element, this function takes one collection, and zips each of its items with the one that follows it:

val random = listOf(3, 1, 4, 1, 5, 9, 2, 6, 5, 4)
println(random.zipWithNext())
// [(3, 1), (1, 4), (4, 1), (1, 5), (5, 9), (9, 2), (2, 6), (6, 5), (5, 4)]

In the example above, we're zipping together a list of numbers. If we want to check the “change” – how much the value increments or decrements each step – we can express this quite elegantly using zipWithNext. We provide a lambda that receives a pair of one number and the one that follows immediately after:

val random = listOf(3, 1, 4, 1, 5, 9, 2, 6, 5, 4)

val changes = random.zipWithNext { a, b -> b - a }
println(changes)
// [-2, 3, -3, 4, 4, -7, 4, -1, -1]

Custom aggregations: `reduce` and `fold`

We have finally arrived at the grand finale for this post – functions that help us build custom aggregations.

The `reduce` function

Let’s set the scene with a small callback – in the previous post, we learned about functions like sum, average, count, and functions to receive the minimum and maximum elements inside a collection. All of these reduce our collection to a single value.

It's possible that we find ourselves in a situation where there’s no out-of-the-box function for how we want to generate a single value for our collection. For example, we may want to multiply all numbers in a list, instead of summing them.

In this case, we can rely on the reduce function as a more generic version for aggregating a collection:

val random = listOf(3, 1, 4, 1, 5, 9, 2, 6, 5, 4)
val multiplicativeAggregate = random.reduce { acc, value -> acc * value }

println(multiplicativeAggregate)
// 129600

As seen in the example above, we call the reduce function with a lambda block which receives two parameters:

An accumulator, which has the same type as our collection, and
An individual item from our collection.

The task of the lambda function is to return a new accumulator. Each invocation, one after the other, receives not only the current element, but also the result of the previous calculation, inside the accumulator.

The function starts with the first element of our collection in the accumulator.
Then it runs our operation – in this example, we multiply the accumulator (which right now is the first number) with the current element (which is the second number).
We’ve calculated a new value, which will be stored in the accumulator, and used when our function is called once more with the third element

This cycle repeats, and we continue to gradually build up the final result in our accumulator. One might even say we’re accumulating that result!

Once we’ve gone through all the elements in our collection, reduce returns the final value that’s inside the accumulator.

As you can see, with reduce, we can hide a lot of mechanics for aggregating our collection behind one function call, and stay true to Kotlin’s concise nature.

The `fold` function

But we can actually go beyond this, and can take this versatility one step further – with the fold operation. Remember – when we used reduce, the iteration starts with the first element of our input collection in the accumulator.

With the fold function, we get to specify our own accumulator – and in fact, it can even have a different type than the items in our input collection! As an example, we can take a list of words, and multiply the number of their characters together using fold:

val fruits = listOf("apple", "cherry", "banana", "orange")
val multiplied = fruits.fold(1) { acc, value ->
    acc * value.length
}
println(multiplied) // 1080

The underlying mechanism is the same – the lambda passed to the fold function gets called with an accumulator and a value, and calculates a new accumulator. The difference is that we specify the initial value of the accumulator ourselves.

(Note that we pass 1 as an initial value for our accumulator, and not 0. That’s because for multiplication, 1 is the neutral element)

Both fold and reduce come in a number of other flavors, as well:

– the sibling functions reduceRight and foldRight change the order of iteration

reduceOrNull allows you to work with empty collections without throwing exceptions.
runningFold and runningReduce don’t just return a single value representing the final state of the accumulator, but instead return a list of all the intermediate accumulator values as well.

That's it!

This concludes my overview of some advanced collection operations in Kotlin – I hope you found this post useful, and have learned something new!

Maybe you can find a point in your code where a predicate, some zipping, chunking or windowing could come in handy! Or maybe you want to explore by defining your own aggregations functions based on the reduce or fold functions.

To get reminded when new Kotlin content is released, follow us here on dev.to/kotlin, and make sure to follow me on Twitter @sebi_io.

Also, use this opportunity sure to find the subscribe button and notification bell on our YouTube channel!

Take care!

Tips & tricks for building a game using Compose for Desktop

Sebastian Aigner — Thu, 06 May 2021 13:03:41 +0000

In the first part of my blog post series about building a small clone of the classic arcade game Asteroids on top of Jetpack Compose for Desktop, we saw how to implement the main game loop, as well as manage state and draw basic shapes. In this post, we will explore some more details of the game implementation. This includes:

Rendering details – making sure game objects don't escape our play area, and using a device-independent coordinate system for rendering
Geometry and linear algebra – the secret sauce that makes the space ships fly
Frame-independent movement – so that our game works consistently.

Let's learn about these topics!

Rendering: Clipping and Coordinate Systems

In the context of rendering, there are two areas that still need our attention – we need to make sure that our game objects are constrained to the game surface, and we need to make a conscious decision about the units of the coordinates we use to describe the position of a game object. We'll discuss both in this section.

Clipping

By default, Compose naively draws your objects without any clipping. This means game objects can poke outside the "play surface", which produces a weirdly fourth-wall-breaking effect:

We constrain the game objects to the bounds of our play surface by applying Modifier.clipToBounds() to the Box which defines our play surface:

Box(modifier = Modifier
                .fillMaxWidth()
                .fillMaxHeight()
                .clipToBounds()
                // . . .

Because all our game elements are drawn as children of this play area Box, using this modifier causes the rendered entities inside it to be cut off at the edges (instead of being drawn over the surrounding user interface):

Device-Independent Pixels and Density

Something else to be aware of when doing any kind of rendering tasks in Compose for Desktop is to keep the units of measurement in the back of your mind.

Wherever I worked with coordinates, I decided to work in device-independent pixels:

The mouse pointer position is stored as a DpOffset
Game width and height are stored as Dps
Game objects are placed on the play surface using their .dp coordinates.

This helps the game work consistently across high-density displays and low-density displays alike. However, it also requires some operations to be performed in the context of Density.

For example, the pointerMoveFilter returns an Offset in pixels – and they are not device-independent!. To work around this, we obtain the local screen density in our composition:

val density = LocalDensity.current

We then use with(density) to access the toDp() extension functions to the Offset into a DpOffset, allowing us to store our targetLocation in this device-independent pixel format:

.pointerMoveFilter(onMove = {
    with(density) {
        game.targetLocation  = DpOffset(it.x.toDp(), it.y.toDp())
    }
    false
})

For storing the play area's width and height, we do a very similar thing, just without wrapping it in a DpOffset:

.onSizeChanged {
    with(density) {
        game.width = it.width.toDp()
        game.height = it.height.toDp()
    }
}

A Game of Geometry and Linear Algebra

Underneath the visualization, the "Asteroids" game builds on just a few basic blocks to implement its mechanics – it is really a game of vectors and linear algebra:

The position, movement, and acceleration of the ship can be described by position, movement, and acceleration vectors.
The orientation of the ship is the angle of the vector between the ship and the cursor.
Circle-circle collisions can be tested based on distance vectors.

Instead of reinventing the ~~wheel~~ vector, I decided to use openrndr-math, which includes an implementation of the Vector2 class including all common operations, like scalar multiplication, addition, subtraction, the dot product, and more. (Ever since listening to the Talking Kotlin episode, I've been meaning to explore OPENRNDR in detail, but that will have to happen in a separate project.)

As somebody who happens to be a bit rusty with their linear algebra skills, I extended the functionality of the class a bit. For example, I defined the following extension function to allow me to access the angle a Vector2 in degrees between 0-360:

fun Vector2.angle(): Double {
    val rawAngle = atan2(y = this.y, x = this.x)
    return (rawAngle / Math.PI) * 180
}

Thankfully, I did not have to spend too much time on figuring out the call to atan2, because I previously watched one of Leland Richardson's live streams where he also uses this function to calculate some angles.

Extensions like this one help me express ideas in ways I understand them myself – and hopefully still will a few months down the road.

I also made use of properties with backing fields to make it possible to access a GameObject's movement vector in different representations:

As a combination of length (speed) and angle
As a vector with x and y coordinates

In the context of a GameObject, that can look like the following, for example:

var speed by mutableStateOf(speed)
var angle by mutableStateOf(angle)
var position by mutableStateOf(position)
var movementVector
    get() = (Vector2.UNIT_X * speed).rotate(angle)
    set(value) {
        speed = value.length
        angle = value.angle()
    }

If we're using this functionality outside of the GameObject class a lot, we could also consider defining additional length / angle getters and setters as extension properties on the Vector2 class, directly.

For our simulation, we still need to do a bit more – we haven't yet addressed the problem of how to update location and speed based on the elapsed real time. Let's talk about the approach for that next.

Frame-Independent Movement With Delta Timing

When building game logic, we need to keep one essential point in mind: Not all frames are created equal!

On a 60 Hz display, each frame is visible for 16ms.
On a 120 Hz display, that number drops to 8.3ms.
On a 240 Hz display, each frame only shows for 4.2ms.
On a system under load, or while running in a non-focused window, the application frame rate may be lower than 60 Hz.

That means that we can't use "frames" as a measurement of time: If we define the speed of our spaceship in relation to the frame rate, it would move four times faster on a 240 Hz display than on a 60 Hz display.

We need to decouple the game logic (and its rudimentary "physics simulation") from the frame rate at which our application runs. Even AAA games don't get this right all the time – but for our projects, we can do better!

A straightforward approach for this decoupling is to use delta timing: We calculate the new game state based on the time difference (the delta) since the last time we updated the game.
This usually means we multiply the result of our calculations with the time delta, scaling the result based on the elapsed time.

In Compose for Desktop, we use withFrameMillis and withFrameNanos. Both of them provide a timestamp, so we just need to keep track of the previous timestamp to calculate the delta:

var prevTime = 0L

fun update(time: Long) {
    val delta = time - prevTime
    // . . .

In my case, a GameObject has an update function that takes a realDelta: Float:

val velocity = movementVector * realDelta.toDouble()
obj.position += velocity

As demonstrated in the code above, I use it to scale the velocity of game objects.

Closing Thoughts

This concludes our tour of building a small game with Compose for Desktop! To see how all the pieces fit together, read the source code (~300 lines of code) on GitHub!

Building Asteroids on Compose for Desktop was great fun! I am always surprised by the iteration speed that Compose for Desktop provides: Getting from a first rectangle to a full game in just one long evening.

Of course, implementing a retro game like Asteroids on modern hardware comes with the luxury of not having to think too hard about performance optimizations, allocations, entity-component systems, or more. When building something more ambitious, these points likely need addressing, and you might find yourself using a few additional libraries besides a Vector2 implementation.

For the next Super Hexagon, pixel roguelike, or other 2D game, however, you can definitely give Compose a shot.

Once again, you can find all 300 lines of source code for this project on GitHub.

If you're looking for additional inspiration, take a look at some other folks building games with Compose!

Vivek Sharma built everybody's favorite dinosaur game
vitaviva built Tetris with Compose
John O'Reilly made a Compose for Desktop CHIP-8 frontend
theapache64 pushes the limits of Compose's builtin components to implement Switch, Check, and Radio Snake

How I built an "Asteroids" game using Jetpack Compose for Desktop

Sebastian Aigner — Thu, 06 May 2021 13:03:23 +0000

A while ago, I tweeted about a small game I had created on top of Jetpack Compose for Desktop: A small clone of the classic arcade game Asteroids, in which you control a space ship with your mouse, and navigate the vastness of space, avoiding and breaking asteroids in the process.

// Detect dark theme var iframe = document.getElementById('tweet-1382668779377762305-462'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1382668779377762305&theme=dark" }

Today, it's time to take a look under the hood and understand how I built a basic version of this game, and how Compose for Desktop helped me achieve it in just one evening!

We will take a look at parts and structures in the code that I find the most interesting. To see how it all fits together, I suggest exploring the whole code on GitHub. The whole implementation is only 300 lines of code, which I hope makes studying and understanding it easy.

The Game

If you're not caught up on your 80s arcade trivia, Asteroids was a popular arcade game where you try to steer your space ship through space, avoiding and destroying asteroids with your ship.

Because of the limitations of the hardware at the time, the game is quite simplistic in appearance: a triangular spaceship moves across a plain background and avoids simple displays of asteroids on a 2D surface.

What makes this a challenge is the interia: Just like a real space ship, your spaceship moves along its course in a straight line at constant speed, and you need to make corrective maneuvers by turning your ship and directing your thrust.

Asteroids has achieved cult status in the arcade game scene. Because of that, I wanted to see what it would take to recreate this experience using Jetpack Compose for Desktop!

The Building Blocks

I have roughly divided the project into a few building blocks that make up the project, and that we will talk about. Namely, those are:

The Game Loop
Game State Management
Rendering to the Screen

In the second part of this series on building a game with Compose for Desktop, we will also look at additional rendering details, the geometry and linear algebra behind the game, and frame-independent movement.

Let's dive right in!

The Game Loop

At the center of most games stands the game loop. It acts as the entry point that calls the game logic code. This is a fundamental difference between implementing typical declarative user interfaces and building games:

Declarative UI is usually mostly static, and reacts to user actions (clicking, dragging) or other events (new data, computation progress...)
Games run their logic many times per second, simulating the game world and its entities one frame at a time.

That is not to say that these two approaches are incompatible! All we need to run a main "game loop" is to get our function to execute once per frame. In Jetpack Compose, we have the withFrame family of functions (withFrameMillis, withFrameNanos), which can help us achieve exactly that.

Let's assume we already have a game object – we will talk about state management shortly. We can then create a LaunchedEffect which asks Jetpack Compose for Desktop to call our update function whenever a new frame is rendered:

LaunchedEffect(Unit) {
    while (true) {
        withFrameNanos {
            game.update(it)
        }
    }
}

withFrameNanos is a suspending method. Its exact implementation is described in the documentation:

withFrameNanos suspends until a new frame is requested, immediately invokes onFrame with the frame time in nanoseconds in the calling context of frame dispatch, then resumes with the result from onFrame.

The frame time, which it provides us with, will also come in handy, as we will see in the second part of this blog post series, when we talk about frame-independent movement.

Game State Management

Jetpack Compose is excellent at managing state, and when building a game like Asteroids, we can use the same mechanisms to keep track of the data attached to game objects or the current play session, to name just two examples.

As suggested in the previous section, my Asteroids game has a Game class, an instance of which is wrapped in a remember call in the main composition.

val game = remember { Game() }

It acts as a container for all game-related data. For example:

Game object information (in a mutableStateListOf)
The current game phase (RUNNING / STOPPED)
The size of the playing field (based on window dimensions)

Inside the Game object, we treat the state data as mutable, and make any state changes as we see fit.

Game Objects

Individual game objects once again group the state belonging to an individual game entity: a spaceship, an asteroid, or a bullet, and provide methods to modify their state, spawn new game objects, or check their relation to other game objects.

In my implementation of Asteroids, all game objects share a lot of behavior, from the way they move through the environment to how they check their collision – we'll talk about the geometry and linear algebra that goes into that a bit later.

The GameObject class provides implementations for these shared behaviors:

sealed class GameObject(speed: Double = 0.0, angle: Double = 0.0, position: Vector2 = Vector2.ZERO) {
    var speed by mutableStateOf(speed)
    var angle by mutableStateOf(angle)
    var position by mutableStateOf(position)
    var movementVector /* ... */
    abstract val size: Double

    fun update(realDelta: Float, game: Game) {
        val velocity = movementVector * realDelta.toDouble()
        position += velocity
        position = position.mod(Vector2(game.width.value.toDouble(), game.height.value.toDouble()))
    }

    fun overlapsWith(other: GameObject): Boolean {
        return this.position.distanceTo(other.position) < (this.size / 2 + other.size / 2)
    }
}

For example, the ShipData class inherits speed, angle, position and its update method from GameObject, but defines its own size, angle, and a function to fire a bullet:

class ShipData : GameObject() {
    override var size: Double = 40.0
    var visualAngle: Double = 0.0

    fun fire(game: Game) {
        val ship = this
        game.gameObjects.add(BulletData(ship.speed * 4.0, ship.visualAngle, ship.position))
    }
}

Note that the ShipData (or even a GameObject in general) does not include any logic on how to render this item to the display – with Jetpack Compose, keeping state and presentation separated is quite easy.

Because a lot of behavior is shared between all types of entities in the game, our main game loop can treat them as the supertype GameObject for the most part, and only specific interactions between certain types of objects, like bullet-asteroid or asteroid-player collisions, need to be handled specifically.

Rendering to the Screen

I found that in Jetpack Compose, separating game data from the visual representation comes quite naturally. Game objects like a ship, an asteroid, or a bullet are all represented in two parts:

A class holding the state associated with the game object (in terms of "Compose state" – via mutableStateOf and friends) – We briefly talked about this in the previous section.
A @Composable, defining the rendering based on the game object's data.

To illustrate the latter, here's the minimal visual representation of the Asteroid composable. It receives asteroidData, which is the container for all information regarding the state of this particular game object:

@Composable
fun Asteroid(asteroidData: AsteroidData) {
    val asteroidSize = asteroidData.size.dp
    Box(
        Modifier
            .offset(asteroidData.xOffset, asteroidData.yOffset)
            .size(asteroidSize)
            .rotate(asteroidData.angle.toFloat())
            .clip(CircleShape)
            .background(Color(102, 102, 153))
    )
}

This code snippet is enough to describe the whole visual representation of an asteroid.

We start with a Box – one of Compose's most basic layout primitives, which allows us to have entities overlap (which is useful since we manually take care of placing the individual entities). We then use Jetpack Compose's Modifiers to specify the position of the asteroid in the form of an offset, its size, rotation angle, shape (by clipping a CircleShape), and background color.

Note that Compose offers quite high-level APIs even for these basic shapes – for example, we can use .rotate directly, without having to manually do geometry work to figure out how to get our entities facing the right way.

To keep this snippet as concise as possible, I've also introduced some extension functions on GameObject that make it possible to reuse the logic of computing the offset of a game object based on its position and size, called xOffset and yOffset, which I've snuck into the previous code snippet already. Their implementation is relatively straightforward:

val GameObject.xOffset: Dp get() = position.x.dp - (size.dp / 2)
val GameObject.yOffset: Dp get() = position.y.dp - (size.dp / 2)

A slightly more complicated composable would be the Ship component, which combines the shapes of a triangle and circle to create a minimalistic spaceship:

@Composable
fun Ship(shipData: ShipData) {
    val shipSize = shipData.size.dp
    Box(
        Modifier
            .offset(shipData.xOffset, shipData.yOffset)
            .size(shipSize)
            .rotate(shipData.visualAngle.toFloat())
            .clip(CircleShape)
            .background(Color.Black)
    ) {
        Canvas(modifier = Modifier.fillMaxSize(), onDraw = {
            drawPath(
                color = Color.White,
                path = Path().apply {
                    val size = shipSize.toPx()
                    moveTo(0f, 0f) // Top-left corner...
                    lineTo(size, size / 2f) // ...to right-center...
                    lineTo(0f, size) // ... to bottom-left corner.
                }
            )
        })
    }
}

The Box defining the ship is quite similar to the one we saw for an Asteroid, but we additionally add a Canvas to draw some additional shapes on top of our spaceship – in this case, a triangle path. In typical Compose fashion, we just add this Canvas in the lambda block following our Box, meaning the Canvas will inhert the coordinate system of its parent, including its offset and rotation.

These composables are then just rendered to a play surface – nothing more than a Box with a locked aspect ratio of 1.0f (to keep it quadratic). Of course, applying some artistic talent to these visual representations of the game is also possible, but we're keeping it minimal for now.

Continued in Part 2

There's still a bit more work to do until we can call our game done. In part 2 of this blog post series, we will look at additional rendering details, the geometry and linear algebra behind the game's simple physics simulation, as well as frame-independent movement. Read on and find out!

Why Learn Kotlin?

Sebastian Aigner — Wed, 28 Apr 2021 18:00:55 +0000

Ksenia Shneyveys, Kotlin Marketing Manager for Education, shares insights on how and why to get started with the Kotlin programming language.

We would love to hear about your own motivations for learning Kotlin by leaving your story on our official blog! If you share your story with us, you will also have the chance to win an “Atomic Kotlin” ebook!

Kotlin has always been and continues to be a modern language in the industry, addressing the real needs of real developers. It is increasingly being adopted in many trending fields, including mobile, web, server-side and cloud development, data science, and education.

This all gives a strong indication that there is already significant demand for Kotlin developers and there will continue to be in the future.

So where can you start learning this skill? “Atomic Kotlin”!

This book is suited for Kotlin learners of all levels, and it is available in print and as an ebook. It breaks Kotlin programming language concepts into atoms, and provides hands-on exercises inside IntelliJ IDEA.

To celebrate the recent release of “Atomic Kotlin”, we asked our Twitter community to share their motivation for learning Kotlin. You all did not disappoint! There were a lot of great responses from the community, and we saw a couple of patterns emerging. In this post, we are going to share with you some of the answers people gave about why Kotlin is a great language to learn.

Buy your copy

Modern Language

#atomickotlin
I love Kotlin because it is clean, logical, safe, fast, modern, flexible, intuitive, versatile, and sits on the shoulder of the Java giant.
— Jan Meww (@JanMeww) March 3, 2021

#atomickotlin I want to learn more about Kotlin because of the modern syntax and some new ideas (e.g. coroutines) it brings to the current Java Web Development. Have tried it for some weeks and has been a bliss!!!
— Fabio Salas (@fabiosalasm) March 2, 2021

Kotlin is a modern programming language that combines all the best bits of imperative, object-oriented, and functional programming. It is general-purpose and multi-paradigm, and conciseness and safety are some of the language's key features.

Easy to Learn

Why I want to learn Kotlin? well..You don’t come across a language that often which is as elegant and easy to learn like Kotlin. To put icing on the cake it can coexist with your Java ecosystems as well ..what more can you ask #atomickotlin
— Nirmal (@thooskoo) March 15, 2021

Kotlin’s syntax is simple to grasp for beginners, while at the same time, the language offers sophisticated powerful features for experienced programmers.

Kotlin can build on the learners’ previous programming experience. It is simple to grasp for those with a Java or Python background. Kotlin’s syntax is also easy to learn for iOS developers because it is based on the same modern concepts they are already familiar with.

Great Materials

I have gone through the sample of Atomic kotlin book, solved exercises from github repo. It's truely awesome & I want to learn the whole content. I want to use only one language to most of my application development to ship it to different platform - Kotlin #atomickotlin
— Kalaiselvan (@kalaiselvan369) March 5, 2021

There is a lot of up-to-date material available to help you learn Kotlin. One of our favorite resources for learning Kotlin from scratch is “Atomic Kotlin”. Readers can see their progress while solving the tasks that are checked automatically within IntelliJ IDEA. There are hints and solutions to help them out if they get stuck. All the examples in "Atomic Kotlin" are available in this GitHub repository. You can compile, run, and test the examples which are automatically extracted directly from the book.

Buy your copy

You can learn what the authors of "Atomic Kotlin", Bruce Eckel and Svetlana Isakova, think about learning the language in this episode of the JetBrains Connect series. In it, they discuss the question of why to learn Kotlin, with host Paul Everitt:

Multiplatform

#atomickotlin

Want to learn Kotlin since I want to be a multi platform developer & focus more on building the product in different platforms rather than on learning different languages. I believe Kotlin would give me feathers to fly between platforms & reach my true potential.
— jplus (@jplus62611121) March 15, 2021

I'm a Ruby developer but want to learn Kotlin as my next language because it have all signs of a modern and concise programming language and it reads well too, which is important. I can build various things with it starting from API to fully-fledged Android app. Fun #atomickotlin
— Костромицкий Денис (@mojobiri) March 4, 2021

As a language that supports multiplatform targets, you can run Kotlin on virtually any device these days, be it a PC or a Mac, and also as native code. This means you can build mobile, web frontend, and backend applications with Kotlin as well.

In addition to being the official language for Android development, Kotlin is a proven technology for building cross-platform mobile applications. It eliminates all the disadvantages of other leading approaches and lets you create mobile apps with native performance and UIs while sharing the business logic completely. Visit the Kotlin Multiplatform Mobile portal to learn more.

Progression from Java

I really like the JVM, and I already know some Kotlin, but I would definitely like to learn more and get better at it, and learn more about the JVM too. Kotlin combines a lot of features from languages that I really like. #atomickotlin
— Moiré (@Moire9_) March 4, 2021

Because I’m finishing my studies which were heavily focused on Java and I just started a job in which I use Kotlin every day. No reason not to exceed the expectations! #atomickotlin
— Bartosz Rogowski (@rogowskibart) March 13, 2021

#atomickotlin
Because I want to write Kotlin, not Java with Kotlin syntax. Currently coding together with Spring and I love it.
— MeSmash (@MeSmash3) March 2, 2021

Kotlin’s interoperability allows it to be introduced seamlessly anywhere you’re already using Java. Kotlin fixes some of the issues Java suffers from and has some features that are absent from Java.

Career prospects

As a self-learner, I started with a couple of Java courses in December. Since then I've been pursuing Kotlin and have been engaged in learning the Kotlin ecosystem to land my first dev job! Having material to build on my foundation of the language will be impactful! #atomickotlin
— Bryan (@Lidberg_B) March 13, 2021

Knowing, cOncise, pragmaTic, Legible, sImple, perfomiNg... #atomickotlin
My learning with these features will make my career grow and my university dream came true through this language.
— Miguel Paulista (@mikePaulista_13) March 9, 2021

Many great companies already use Kotlin to build their products, and Kotlin skills are increasingly in demand as more and more businesses are adopting the language. Indeed, the number of Kotlin job postings has skyrocketed by 1400% since 2017 (Source: Dice).

Community Driven

#atomickotlin Kotlin is a community driven language and they give great importance for the feedback from devs. I feel good to be invested in such Lang and I believe it has a great future!
— (@GopalAkshintala) March 3, 2021

Because I'm believing in Kotlin Team and their works(books, features, libraries and everything made by Kotlin)#atomickotlin
— Hamza GATTAL (@hmzgtl05) March 13, 2021

Since its very beginning in 2011, Kotlin has been developed as an open-source language.

Kotlin evolves with the help of our diverse community, which includes almost 200 Kotlin User Groups, 37K+ Kotlinlang Slack users, and countless other members spread across our forum, our sub-Reddit, YouTube, Twitter, and many other platforms. Over 450 contributors are working on Kotlin, including 90 JetBrains developers.

Your feedback provides the basis for our roadmap. Thank you for your continued support!

Why did you Learn Kotlin?

If you haven’t already taken up Kotlin, we hope that this post has left you feeling inspired to do so. We would love to hear about your own motivations for learning Kotlin by leaving your story on our official blog! If you share your story with us, you will also have the chance to win an “Atomic Kotlin” ebook!

We’ll select 5 winners from the commenters on blog.jetbrains.com on May 12.

Diving into Kotlin collections

Sebastian Aigner — Mon, 29 Mar 2021 18:00:41 +0000

This blog post accompanies a video from our YouTube series which you can find on our Kotlin YouTube channel, or watch here directly!

Kotlin Collections! You’ve heard of them, you’ve used them – so it makes sense to learn even more about them! Kotlin's standard library provides awesome tools to manage groups of items, and we’re going to take a closer look!

Let's see what types of collections the Kotlin standard library offers, and explore a common subset of operations that’s available for all of the collections you get in the standard library. Let’s get started.

In the Kotlin standard library, we have three big types of collections: Lists, Sets, and Maps. Just like many other parts of the standard library, these collections are available anywhere you can write Kotlin: on the JVM, but also in Kotlin/Native, Kotlin/JS, and common Kotlin code.

Lists

Let’s start with the most popular candidate of a collection in Kotlin: a List. To rehearse:

A list is a collection of ordered elements. That means that you can access the elements of a list using indices – so you can say “give me the element at position two”. There’s also no constraints on duplicate elements in our list. We can just put in whatever elements we’d like. So, very few constraints on content, and maximum versatility in how we access the elements!

val aList = listOf(
    "Apple",
    "Banana",
    "Cherry",
    "Apple"
)

aList // [Apple, Banana, Cherry, Apple]

aList[2] // Banana

Sets

Next up, we have the Set! Sets are groups of objects where we don’t care about the order of elements. Instead, we want to make sure that our collection never contains any duplicates.

That’s the key property of a set: all of its contents are unique.

That makes sets a bit more of a specialized data structure, but there’s a good chance you want to use them in everyday scenarios anyway.

What are typical things you might want to store in a set? Tags, for example. Or, maybe you’re building a social network, and you want to store the IDs of all the friends that a certain user has. In both cases, you don't want to have duplicates in these collections, and probably don't care about the order.

A set can help you enforce these constraints without having to really think about it, and without manual duplication checks.

val emotions = setOf(
    "Happy",
    "Curious",
    "Joyful",
    "Happy", // even if we try to add duplicates...
    "Joyful" // ...to our set...
)

println(emotions) // ...the elements in our set stay unique!
// [Happy, Curious, Joyful]

Sets are actually also a common mathematical abstraction. Typical mathematical concepts, like unions, intersections, or the set difference also translate neatly into Kotlin code.

Maps

Last, but certainly not least, we have Map. A map is a set of key-value pairs, where each key is unique. It’s also sometimes called a “dictionary” for that reason. You encounter maps whenever you’re associating data – storing a persons name and their favorite pizza topping, or associating a license plate with vehicle information.

val peopleToPizzaToppings = mapOf(
   "Ken" to "Pineapple",
   "Lou" to "Peperoni",
   "Ash" to "Ketchup"
)

println(peopleToPizzaToppings)
// {Ken=Pineapple, Lou=Peperoni, Ash=Ketchup}

println(toppings["Ash"])
// Ketchup

Key-value pairs are everywhere, and just like in many other languages, maps are the go-to way to manage them in Kotlin.

Collections can be mutable

By default, these collections in Kotlin are read-only. This is in the spirit of immutability which accompanies typical functional paradigms – instead of changing the contents of a collection, you create a new collection with the changes applied, which you can then safely pass around in your application, ensuring that the original collection stays unchanged.

But we also have mutable flavors of all of the collections in Kotlin: we have MutableList, MutableSet, and MutableMap. Those are modifiable, meaning you can comfortably add and remove elements. With data where you’re inherently expecting change, you’d probably use these mutable variants.

Collections are iterable

Kotlin collections being iterable means that the standard library provides a common, standardized set of typical operations for collections, for example, to retrieve their size, check if they contain a certain item, and more.

Lists and sets directly implement the Collection interface, which in turn implements the Iterable interface. Maps have an iterator() operator function, and provide iterable properties, like their set of keys, their list of values, as well as the entries of the map, so key-value pairs.

Let’s learn about some shared functionality of iterables. The following examples are going to use a list, but really, we can just assume that we’re just working with an Iterable here – the concrete implementation does not matter. Also, all the functions discussed leave the original collection unchanged.

Looping over collections

A core function of an Iterable, as its name suggests, is that it provides a mechanism to access the elements that our collection contains, one after the other – to iterate it.

The easiest way to go through all the elements in a collection is the basic Kotlin for loop. When we use the for loop with an Iterable, the in operator cleverly understands that we want to go over the iterator:

val fruits = listOf(
    "Apple",
    "Banana",
    "Cherry"
)

for(fruit in fruits) {
    println(fruit)
}

// Apple
// Banana
// Cherry

In a more functional style, we can also write this same snippet using the forEach function:

fruits.forEach { fruit ->
    println(fruit)
}

// Apple
// Banana
// Cherry

In this case, forEach takes every element from our collection, and calls a function (which we provide) with the element as its argument.

Transforming collections: map

Let's continue with a classic when it comes to transforming collections: the map function! (Don’t be confused! The map function has nothing to do with the Map collection type. You can treat them as two completely different things.)

Just like the forEach function, the map function is of higher order. So, it:

Takes each element from our collection,
applies a function to it, and
creates another collection, containing the return values of those function applications.

The result of the map function doesn’t have to be the same type as the one of our input collection, either.

This makes the map function very versatile – whether you want to parse a collection of strings into a collection of integers, or resolve a list of user names to a list of full user profiles –– if you’re transforming one collection into another, it’s probably a good first instinct to think map.

val fruits = listOf(
    "Apple",
    "Banana",
    "Cherry"
)

val stiurf = fruits.map {
    it.reversed()
}

However, you might have a transformation inside your map function where you can’t generate valid results for all input elements. In this case, we can use the mapNotNull function, and our resulting collection will only contain those function results that evaluated to an actual value. This also ensures that type of our resulting variable is non-nullable.

val strs = listOf(
    "1",
    "2",
    "three",
    "4",
    "V"
)

val nums: List<Int> = strs.mapNotNull {
    it.toIntOrNull()
}

println(nums)
// [1, 2, 4]

If we need to keep track of the index of the element which we’re currently transforming, we can use the mapIndexed function. It’s quite similar in how it works, but in this case, we get two parameters in our transformation function: the index and the value:

val rank = listOf(
    "Gold",
    "Silver",
    "Bronze"
)

val ranking = rank.mapIndexed { idx, m ->
    "$m ($idx)"
}

println(ranking)
[Gold (0), Silver (1), Bronze (2)]

Filtering collections: filter and partition

If we have a collection, but we’re only interested in elements that fulfil a certain condition, the filter function comes to the rescue!

Just like the previous examples, filter accepts another function as its parameter. This time, instead of defining a transformation, we’re defining what you can call a predicate here.

A predicate is a function that takes a collection element and returns a boolean value: true means that the given element matches the predicate, false means the opposite. So this predicate acts as the “doorman” – if the value is true, the collection item is let through to the result collection, otherwise, it is discarded.

open class Person(val name: String, val age: Int) {
    override fun toString() = name
}

class Cyborg(name: String) : Person(name, 99)

val people = listOf(
    Person("Joe", 15),
    Person("Agatha", 25),
    Person("Amber", 19),
    Cyborg("Rob")
)

val discoVisitors = people.filter {
    it.age >= 18
}

println(discoVisitors)
// [Agatha, Amber, Rob]

If you’re testing a negative condition, you can use the filterNot function instead, which behaves identically, but inverts the condition.

val students = people.filterNot {
    it.age >= 18
}

println(students)
// [Joe]

Note that both filter and filterNot discard elements where the condition doesn’t match. But maybe we don’t want to discard the “other half” of elements, and instead we want to put those into a separate list. This is where the partition function comes into play.

By using partition, we combine the powers of filter and filterNot. It returns a pair of lists, where the first list contains all the elements for which the predicate holds true, and the second contains all the elements that fail the test. So, in our doorman analogy, instead of sending people who fail the check away, we just send them to a different place. (Using parentheses, we can destructure this pair of lists directly into two independent variables.)

val (adults, children) = people.partition {
    it.age >= 18
}

println(adults)
// [Agatha, Amber, Rob]

println(children)
// [Joe]

If you’re bringing a collection of nullable items to the party, you can use the filterNotNull function which, as you may have guessed, automatically discards any elements that are null, and gives you a new collection with an adjusted, non-nullable type accordingly.

Speaking of adjusting types – if your collection contains multiple elements from a type hierarchy, but you’re only interested in elements of a specific type, you can use filterIsInstance, and specify the desired type as a generic parameter.

val people = listOf(
    Person("Joe", 15),
    null,
    Person("Agatha", 25),
    null,
    Person("Amber", 19),
    Cyborg("Rob"),
    null,
)

val actualPeople = people.filterNotNull()

println(actualPeople)
// [Joe, Agatha, Amber, Rob]

val cyborgs = people.filterIsInstance<Cyborg>()

println(cyborgs)
// [Rob]

Retrieve collection parts: take and drop

Filtering allowed us to apply a predicate function, and create a new collection containing items that match. But what about the even simpler cases? Sometimes, we just want to grab a few elements from our collection.

For that, we have the take and drop functions. You might already be able to guess what they do. take gives you a collection of the first n elements from your original collection. So take(2) is going to give you the first two elements. On the opposite hand, drop(3) is going to leave out the first three elements of your original collection, and only gives you everything that follows after those three elements. And you don’t have to be afraid to “overdrop” either – dropping more elements from a collection than it contains just gives you an empty list:

val objects = listOf("🌱", "🚀", "💡", "🐧", "⚙️")

val seedlingAndRocket = objects.take(2)

println(seedlingAndRocket)
// [🌱, 🚀]

val penguinAndGear = objects.drop(3)

println(penguinAndGear)
// [🐧, ⚙️]

val nothing = objects.drop(8)

println(nothing)
// []

println(objects) // remember, the original collection is not modified!
// [🌱, 🚀, 💡, 🐧, ⚙️]

One huge benefit of the functions we’ve seen so far is their composability: Because mapping, filtering, taking, dropping, and all their friends return a new collection, it’s easy to just take that result, and immediately use it as an argument for the next collection function, turning collection into collection into collection.

However, we should keep in mind that chaining a number of these functions together means we generate a bunch of intermediate collections. Now, this isn’t going to set your computer on fire immediately, but it is still something to be aware of, especially when you work with very large collections. For this case, Kotlin has a few aces up its sleeve as well, called sequences, but we will dive into those at a later point.

Aggregating collections: sums, averages, minimums, maximums, and counting

Once we’re done transforming our data, we might want to get a single result value out of it. If we have a collection of numerical values like integers or doubles, we get some nice functions called average and sum out of the box, which help us calculate those values.

val randomNumbers = listOf(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 6)

println(randomNumbers.average())
// 4.09090909090909091

println(randomNumbers.sum())
// 45

In some situations (...or, we might say, sum situations...), we have a collection of more complex objects, and want to still add them up somehow, based on their properties. Of course, we could first use the map function to obtain a collection containing only numbers – but by using the sumOf function, we can do all of this in a single function call: we can pass a function that acts as a selector (so a function that gives us whatever number we want to associate with the element) and sumOf will use the result of that selector function to add up all our elements.

val randomNames = listOf("Dallas", "Kane", "Ripley", "Lambert")

val cumulativeLength = randomNames.sumOf { it.length }

println(cumulativeLength)
// 23

If we’re only interested in the greatest or smallest value contained in our collection of numbers, we can use the maxOrNull and minOrNull functions.

println(randomNumbers.minOrNull())
// 9

println(randomNumbers.maxOrNull())
// 1

And just like sumBy, we have the sibling functions maxOf and minOf, where we once again pass a selector function, which is going to be used to determine the maximum or minimum of a collection.

val longestName = randomNames.maxOf { it.length }

println(longestName)
// 7

val shortestName = randomNames.minOf { it.length }

println(shortestName)
// 4

If we just care about the number of elements contained in our collection, we can use the count function – either without any parameters, to just get the number of all elements, or using a predicate. So that’s like filtering the collection first, and then counting the elements. But again, all wrapped into one.

val digits = randomNumbers.count()

println(digits)
// 11

val bigDigits = randomNumbers.count { it > 5 }

println(bigDigits)
// 3

There’s also the powerful joinToString function, which allows us to turn all elements of our collection into a string, complete with a metric ton of customization options like separators, prefixes and postfixes, limits or a placeholder if you have more elements than what your specified limit allows. And even joinToString accepts a transformation function, once again, so you don’t need to do some kind of separate mapping beforehand, it’s all built in. Truly powerful stuff to create a string from a collection.

val str = randomNumbers.joinToString (
    separator = "-",
    prefix = "pi://",
    limit = 5
) {
    "[$it]"
}

println(str)
// pi://[3]-[1]-[4]-[1]-[5]-...

If you want to refresh what kind of magic we can do with Kotlin strings, watch the Kotlin Standard Library episode that takes us into the depth of strings!

More collection goodness, coming soon!

That concludes our overview of Kotlin collections!

Next, we’re going to step up our game even more, and will take a look at some advanced collection functionality. Some of the functions we’ve seen today actually have some additional variants to them, which are worth an introduction. There’s also the whole world of modifying collections. Plus, each type of collection we’ve seen, Lists, Sets, and Maps, all have their own specialized functionality as well, We’re in for a whole bunch more Kotlin collection content!

Make sure you don’t miss it! To get reminded when new content is released, follow us here on dev.to/kotlin, and make sure to follow me on Twitter @sebi_io.

Also, make sure to find the subscribe button and notification bell on our YouTube channel!

If you don’t want to wait until that episode comes out, there’s only one solution! It’s time to go and explore some more Kotlin!

Publishing your Kotlin Multiplatform library to Maven Central

Ekaterina Petrova — Thu, 25 Mar 2021 12:40:40 +0000

Now when we've built our first Kotlin Multiplatform library and learned about multiplatform library publishing format nothing can stop us from going public and releasing our library to MavenCentral!

Registering a Sonatype account

If this is your first library, or you’ve only ever used Bintray to do this before, you will need to first register a Sonatype account.

There are many articles describing the registration process on the internet. The one from GetStream is exhaustive and up to date. You can start by following the first four steps, including "Generating a GPG key pair":

Register a Jira account with Sonatype (you can use my issue as an example). ✅
Verify your ownership of the group ID you want to use to publish your artifact by creating a GitHub repo. ✅
Generate a GPG key pair for signing your artifacts. ✅
Publish your public key. ✅
Export your private key. ✅

When the Maven repository and signing keys for your library are prepared, we are ready to move forward and set up our build to upload the library artifacts to a staging repository and then release them!

Setting up publication

Now we need to tell Gradle how to publish our libraries. Most of the work is already done by maven-publish and Kotlin Gradle Plugins – all the required publications are created automatically. We've already seen the result when we published our library to the local Maven repository. But for publishing it to Maven Central we need to take some additional steps:

Configure public Maven repository URL and credentials.
Provide a description and javadocs for all library components.
Sign publications.

Let's handle all of these tasks by writing some Gradle scripts! I suggest extracting all the publication-related logic from our library module build.script, so you can easily reuse it for other modules in the future.

The most idiomatic and flexible way to do that is to use Gradle’s precompiled script plugins. Our build logic will be provided as a precompiled script plugin and could be applied by plugin ID to every module of our library.

To implement this, we need to put our publication logic into a separate Gradle project:

Add a new gradle project convention-plugins inside your library root project by creating a new folder named
convention-plugins with build.gradle.kts in it.

Put the following in the build.gradle.kts:

plugins {
    `kotlin-dsl` // Is needed to turn our build logic written in Kotlin into Gralde Plugin
}

repositories {
    gradlePluginPortal() // To use 'maven-publish' and 'signing' plugins in our own plugin
}

Create a convention.publication.gradle.kts file in the convention-plugins/src/main/kotlin directory. This is where all the publication logic will be stored.

Put all the required logic there. Applying just maven-publish is enough for publishing to the local Maven repository, but not to Maven Central. In the provided script we get the credentials from local.properties or environment variables, do all the required configuration in the ‘publishing’ section, and sign our publications with the signing plugin:

import org.gradle.api.publish.maven.MavenPublication
import org.gradle.api.tasks.bundling.Jar
import org.gradle.kotlin.dsl.`maven-publish`
import org.gradle.kotlin.dsl.signing
import java.util.*

plugins {
   `maven-publish`
   signing
}

// Stub secrets to let the project sync and build without the publication values set up
ext["signing.keyId"] = null
ext["signing.password"] = null
ext["signing.secretKeyRingFile"] = null
ext["ossrhUsername"] = null
ext["ossrhPassword"] = null

// Grabbing secrets from local.properties file or from environment variables, which could be used on CI
val secretPropsFile = project.rootProject.file("local.properties")
if (secretPropsFile.exists()) {
   secretPropsFile.reader().use {
       Properties().apply {
           load(it)
       }
   }.onEach { (name, value) ->
       ext[name.toString()] = value
   }
} else {
   ext["signing.keyId"] = System.getenv("SIGNING_KEY_ID")
   ext["signing.password"] = System.getenv("SIGNING_PASSWORD")
   ext["signing.secretKeyRingFile"] = System.getenv("SIGNING_SECRET_KEY_RING_FILE")
   ext["ossrhUsername"] = System.getenv("OSSRH_USERNAME")
   ext["ossrhPassword"] = System.getenv("OSSRH_PASSWORD")
}

val javadocJar by tasks.registering(Jar::class) {
   archiveClassifier.set("javadoc")
}

fun getExtraString(name: String) = ext[name]?.toString()

publishing {
   // Configure maven central repository
   repositories {
       maven {
           name = "sonatype"
           setUrl("https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/")
           credentials {
               username = getExtraString("ossrhUsername")
               password = getExtraString("ossrhPassword")
           }
       }
   }

   // Configure all publications
   publications.withType<MavenPublication> {

       // Stub javadoc.jar artifact
       artifact(javadocJar.get())

       // Provide artifacts information requited by Maven Central
       pom {
           name.set("MPP Sample library")
           description.set("Sample Kotlin Multiplatform library (jvm + ios + js) test")
           url.set("https://github.com/KaterinaPetrova/mpp-sample-lib")

           licenses {
               license {
                   name.set("MIT")
                   url.set("https://opensource.org/licenses/MIT")
               }
           }
           developers {
               developer {
                   id.set("KaterinaPetrova")
                   name.set("Ekaterina Petrova")
                   email.set("ekaterina.petrova@jetbrains.com")
               }
           }
           scm {
               url.set("https://github.com/KaterinaPetrova/mpp-sample-lib")
           }

       }
   }
}

// Signing artifacts. Signing.* extra properties values will be used

signing {
   sign(publishing.publications)
}

Go back to your library project. Ask Gradle to prebuild your plugins by adding the following in the root settings.gradle:
```
includeBuild("convention-plugins")
```
Now we can apply this logic in our library build.script. In the plugins section, replace using maven-publish with using our conventional.publication.
```
plugins {
   kotlin("multiplatform") version "1.4.30"
   id("convention.publication")
}
```
Don’t forget to create a local.properties file with all the necessary credentials and make sure you have added it to .gitignore 🗝:
```
signing.keyId=...
signing.password=...
signing.secretKeyRingFile=...
ossrhUsername=...
ossrhPassword=...
```

Now take a deep breath, make ./gradlew clean and sync the project.

New Gradle tasks related to the Sonatype repository should appear in the publishing group – that means that everything is ready for you to publish your library!

Publishing your first library to MavenCentral

In the beginning of the article I promised you that you will be able to publish your library in just a one click – and now is the moment of truth! To upload your library to Sonatype Repository just run:

./gradlew publishAllPublicationsToSonatypeRepository

The so-called staging repository will be created, and all the artifacts for all publications will be uploaded to that repository. All that is now needed is to check that all the artifacts you wanted to upload have made it there and to press the “release” button!

These final steps are well-described in the now-familiar article. In short, you need to:

Go to https://s01.oss.sonatype.org/ and log in using the credentials you used in Sonatype Jira.
Find your repository in the ‘Staging repositories’ section.
Close it.
🚀 Release it!

Go back to the Jira Issue you created and let them know you released your first component to activate the sync to Maven Central. This step is needed only if it’s your first release.

Soon your library will become available at https://repo1.maven.org/maven2/ and other developers will be able to add it as a dependency. And in a couple of hours, it will become discoverable in Maven Central Repository Search!

Conclusion

Congratulations! 🎉 You’ve just created your first Kotlin Multiplatform Library and published it on Maven Central!

This is how you can now depend on the published version:

kotlin {
    android()
    ios ()
    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("io.github.katerinapetrova:mpp-sample-lib:1.0.0")
            }
        }
}

Pretty simple, right? If you check the external dependencies section, you will see that it is quite clever as your project only downloads the artifacts of the platforms you actually target, not all of them every time. Thanks to the Gradle module metadata feature, you only have to specify dependencies on the library once in the shared source set, even if it is used in platform source sets.

A lot of work has been done, but of course, it’s just the beginning of the journey. The most interesting part is ahead: to support and improve your library continuously, so you can provide your users the best DX and evolve the KMM ecosystem together with other library creators and contributors.

Next useful steps

Now that you have published your library to Maven Central, it's time to let others know – and what better way than to add a badge to your project's README!
Add your library to the community-driven list of Kotlin Multiplatform libraries to increase its discoverability.
Take a look into the possibility to automate the release process and share your experience with the community, if you’ve already successfully made it this far!

KaterinaPetrova / mpp-sample-lib

Sample Kotlin Multiplatform library (jvm + ios + js)

How a Kotlin Multiplatform library is published?

Ekaterina Petrova — Thu, 25 Mar 2021 12:40:27 +0000

In the first part of the series, we've created our first multiplatform library and published it to the local Maven. Before going public, let's discover published artifacts to get an understanding of the multiplatform publishing format.

TL;DR: The Kotlin Gradle plugin creates and configures your library publications automatically, so you don't need to know the details of the publication scheme to successfully deliver your library. But if you are curious, let's discuss it a little!

Discovering your library structure

If you have published regular platform (for example, android) libraries before, you may notice that the publishing format of a multiplatform library differs quite a lot. There are multiple artifacts for one version of your library, their content format is different (.jar vs .klib), and the number of source sets doesn’t match the number of result artifacts.

This is because ordinary publishing is not enough for a multiplatform library. Multiplatform libraries have more complex structures compared to normal ones, so the publication is less trivial as well. Here are key differences to keep in mind:

Multiplatform libraries consist of multiple parts: common parts with expects declarations and platform-specific parts with actual implementations.
Platform-specific code may still be shared across similar platforms (e.g. in a source set shared between the iOS device and simulator, or shared code for all desktop platforms).
There should be the ability to publish all those parts from a multiple host because of Kotlin/Native cross-compilation limitations. For example, the artifacts for iOS or macOS can be built only on Mac-OS.

Considering all that complexity, adding the ordinary multiplatform dependency requires just a single line of code in your the build.gradle file:

dependencies {
    implementation("io.github.katerinapetrova:mpp-sample-lib:1.0.0")
}

So how does this magic work? Maven doesn’t operate with targets, source sets, and compilations. It operates only with projects. A project is everything we build and could depend on. Each project is defined by groupId, artifactId, and version, and these three fields are used by Maven as a coordinate system. This is exactly what you are using when copy-pasting a dependency string to your build.gradle file. These coordinates are defined in a .pom file — an XML representation of a Maven project. Let’s take a look at what we have in the local Maven folder of the library we’ve just published:

We published only one library, but there are multiple folders. Each folder represents a separate maven project, containing different artifacts and a .pom file, which describes the project (we can also call them “artifacts”, as the name of the project is stored in the POM artifactId field).

So the Kotlin Gradle plugin has created publications, which were used by the maven-publish plugin to map the sources of our Kotlin Multiplatform library to the Maven artifacts, on which we later could depend on in the consumer project as Gradle modules. This is how it was done:

Let’s figure out the main points of this transformation:

There is a separate publication for each target. The binary format depends on the target compiler backend:
- .jar with class files for Kotlin/JVM
- .jar with .js or .klib when using IR Compiler for Kotlin/JS
- .klib for Kotlin/Native
There is also an additional root publication that stands for the whole library. It consists of two important parts:
- Kotlin representation of common sources of your library. Kotlin toolchain will use it to provide exact and granular dependencies from your common code to a library's common code.
- Gradle Module Metadata, which tells Gradle where to find other platform-specific parts of a library when you depend on the root artifact in the common source set. This is what allows you to write single-line dependency on a library in a common source set
With the hierarchical project structure enabled, the API of the library’s intermediate source sets is embedded into the library artifacts (common or platform, depending on which targets this set is divided between).

This transformation doesn’t look trivial and the described points are just the tip of the iceberg, but the good news is that all the work is done by the Kotlin Gradle plugin. It creates and configures all the relevant publications automatically, so you don't need to create them manually. That significantly reduces the chance of making a mistake, especially for popular configurations. 🎉

If you want to dive into the details of publication format, I suggest you watch an exciting talk by Dima Savinov, Kotlin Multiplatform team lead.

And now let’s go back to our main goal — making our library available to the world! Check out the last part of the series, which will guide you through the MavenCentral publication process 👀

DEV Community: Kotlin

Idiomatic Kotlin: Solving Advent of Code Puzzles, Binary Boarding

Day 5. Binary Boarding

Solution

Boarding pass: binary representation

Decoding column

Combining row and column

Converting boarding pass to seat ID

Finding the maximum seat ID

Finding the vacant seat ID

Idiomatic Kotlin: Solving Advent of Code Puzzles, Passport Validation

Day 4. Passport processing

Solving Day 4, Part 1

Solving Day 4, Part 2

A refactoring excursion

Returning to solving part 2

Conclusion

Idiomatic Kotlin: Solving Advent of Code Puzzles, Day 2

Idiomatic Kotlin: Solving Advent of Code Puzzles, Day 2

Day 2. Password philosophy

Solution

Parsing input

Password validation

Solving Advent of Code Puzzles in Idiomatic Kotlin

Day 1. Report Repair

How to solve the task

Solution

Solving the task for two numbers

Solving the task for three numbers

Exploring Kotlin Lists in 2021

Lists

What’s a list?

Creating lists

Accessing list items

Slicing

Mutable Lists

Creating mutable lists

Add / Remove / Update

Fill and Clear

In-place modifications

Views on Lists

Outro

Advanced Kotlin Collection Functionality

Checking predicates: any, none and all

Predicates for empty collections

Collection parts: chunked and windowed

The chunked function

The windowed function

Un-nesting Collections: Flatten and Flatmap

Combining collections: zip and unzip

The zip function

The unzip function

The zipWithNext function

Custom aggregations: reduce and fold

The reduce function

The fold function

That's it!

Tips & tricks for building a game using Compose for Desktop

Rendering: Clipping and Coordinate Systems

Clipping

Device-Independent Pixels and Density

A Game of Geometry and Linear Algebra

Frame-Independent Movement With Delta Timing

Closing Thoughts

How I built an "Asteroids" game using Jetpack Compose for Desktop

The Game

The Building Blocks

The Game Loop

Game State Management

Game Objects

Rendering to the Screen

Continued in Part 2

Why Learn Kotlin?

Modern Language

Easy to Learn

Great Materials

Multiplatform

Progression from Java

Career prospects

Community Driven

Checking predicates: `any`, `none` and `all`

Collection parts: `chunked` and `windowed`

The `chunked` function

The `windowed` function

Combining collections: `zip` and `unzip`

The `zip` function

The `unzip` function

The `zipWithNext` function

Custom aggregations: `reduce` and `fold`

The `reduce` function

The `fold` function