Kotlin Functions: Named, Reusable Code Blocks

Why it exists

Functions exist to solve the problem of code repetition and disorganization. Instead of writing the same logic multiple times, you can package it into a single, named block that can be called from anywhere. This makes code easier to read, test, and maintain.

The mental model

Think of a function as a specialized machine on an assembly line. It has a clear name describing its job (like doubleValue), defined inputs it accepts (parameters, like a number x), and a specific output it produces (a return value, like 2 * x). You can use this machine over and over without needing to rebuild it each time.

How it works

You declare a function with the fun keyword, followed by its name, parameters in parentheses, and an optional return type. For example, fun powerOf(number: Int, exponent: Int): Int. Inside the function, parameters are read-only. Kotlin offers powerful features like default parameter values, which let you make arguments optional. For example, fun read(off: Int = 0, len: Int = b.size). This avoids creating many overloaded versions of the same function just to skip a parameter.

When to use it

Use functions for any piece of logic you might need more than once. This is a fundamental concept used for almost everything: performing calculations, updating the UI in response to user input, making network requests, or validating data. Grouping logic into functions makes your app's architecture clean and understandable.

When not to use it

There's almost never a time not to use functions to organize logic. However, avoid creating functions that are too large or do too many unrelated things (a "god function"). A function should have a single, clear responsibility. If a function becomes too complex, it's a sign you should break it down into smaller, more focused helper functions.

One canonical example

A common pattern is using default parameters to simplify function calls. Consider this function: fun greet(name: String, message: String = "Hello") { println("message, name!") }. You can call this in two ways. First, providing all arguments: greet("Alice", "Hi") prints "Hi, Alice!". Second, using the default value: greet("Bob") prints "Hello, Bob!". A common footgun is argument order. If the default parameter came first, like fun greet(message: String = "Hello", name: String), you would have to call it with a named argument: greet(name = "Charlie").