Kotlin (programming language)

Short description: General-purpose programming language derived from Java

Kotlin

Paradigm| Multi-paradigm: object-oriented, functional, imperative, block structured, declarative, generic, reflective, concurrent
Designed by| JetBrains
Developer| JetBrains
First appeared| July 22, 2011; 14 years ago (2011-07-22)
Typing discipline| Inferred, static, strong
Platform|

* Android
* JVM
* JavaScript (Kotlin/JS)
* macOS (incl. Apple silicon support)
* iOS, tvOS, watchOS
* Linux
* Windows
* WebAssembly
* LLVM (Kotlin/Native)

OS| Cross-platform
License| Apache License 2.0
Filename extensions| .kt, .kts, .kexe, .klib
Website| {{{1}}}
Influenced by

* C#
* Eiffel
* Gosu
* Groovy
* Java
* JavaScript
* ML
* Python
* Scala

Influenced
V (Vlang)

Kotlin (/ˈkɒtlɪn/)[1] is a cross-platform, statically typed, general-purpose high-level programming language with type inference. Kotlin is designed to interoperate fully with Java, and the JVM version of Kotlin's standard library depends on the Java Class Library,[2][failed verification] but type inference allows its syntax to be more concise. Kotlin mainly targets the JVM, but also compiles to JavaScript (e.g., for frontend web applications using React)[3] or native code via LLVM (e.g., for native iOS apps sharing business logic with Android apps).[4] Language development costs are borne by JetBrains, while the Kotlin Foundation protects the Kotlin trademark.[5]

On 7 May 2019, Google announced that the Kotlin programming language was now its preferred language for Android app developers.[6] Since the release of Android Studio 3.0 in October 2017, Kotlin has been included as an alternative to the standard Java compiler. The Android Kotlin compiler produces Java 8 bytecode by default (which runs in any later JVM), but lets the programmer choose to target Java 9 up to 20, for optimization,[7] or allows for more features; has bidirectional record class interoperability support for JVM, introduced in Java 16, considered stable as of Kotlin 1.5.

Kotlin has support for the web with Kotlin/JS, either through a classic interpreter-based backend which has been declared stable since version 1.3, or an intermediate representation-based backend which has been declared stable since version 1.8. Kotlin/Native (for e.g. Apple silicon support) is considered beta since version 1.3.[8][9]

## Contents

* 1 History
* 2 Design
* 3 Syntax
* 3.1 Procedural programming style
* 3.2 Main entry point
* 3.3 Extension functions
* 3.4 Unpack arguments with spread operator
* 3.5 Destructuring declarations
* 3.6 Nested functions
* 3.7 Classes are final by default
* 3.8 Abstract classes are open by default
* 3.9 Classes are public by default
* 3.10 Primary constructor vs. secondary constructors
* 3.11 Sealed classes
* 3.12 Data classes
* 3.13 Kotlin interactive shell
* 3.14 Kotlin as a scripting language
* 3.15 Null safety
* 3.16 Lambdas
* 3.17 Complex "hello world" example
* 4 Tools
* 5 Applications
* 6 Adoption
* 7 See also
* 8 References
* 9 External links

## History

A 2D picture of the Kotlin mascot A 3D picture of the Kotlin mascot

In July 2011, JetBrains unveiled Project Kotlin, a new language for the JVM, which had been under development for a year.[10] JetBrains lead Dmitry Jemerov said that most languages did not have the features they were looking for, with the exception of Scala. However, he cited the slow compilation time of Scala as a deficiency.[10] One of the stated goals of Kotlin is to compile as quickly as Java. In February 2012, JetBrains open sourced the project under the Apache 2 license.[11]

The name comes from Kotlin Island, near St. Petersburg. Andrey Breslav mentioned that the team decided to name it after an island, just like Java was named after the Indonesian island of Java[12] (though Java the programming language's name is said to have been inspired by "java" the American slang term for coffee,[13] which itself derives from the island name).[14]

JetBrains hoped that the new language would drive IntelliJ IDEA sales.[15]

The first commit to the Kotlin Git repository was on November 8, 2010.[16]

Kotlin 1.0 was released on February 15, 2016.[17] This is considered to be the first officially stable release and JetBrains has committed to long-term backwards compatibility starting with this version.

At Google I/O 2017, Google announced first-class support for Kotlin on Android.[18]

Kotlin 1.2 was released on November 28, 2017.[19] Sharing code between JVM and JavaScript platforms feature was newly added to this release (multiplatform programming is by now a beta feature[20] upgraded from "experimental"). A full-stack demo has been made with the new Kotlin/JS Gradle Plugin.[21][22]

Kotlin 1.3 was released on 29 October 2018, bringing coroutines for asynchronous programming.[23]

On 7 May 2019, Google announced that the Kotlin programming language is now its preferred language for Android app developers.[6]

Kotlin 1.4 was released in August 2020, with e.g. some slight changes to the support for Apple's platforms, i.e. to the Objective-C/Swift interop.[24]

Kotlin 1.5 was released in May 2021.

Kotlin 1.6 was released in November 2021.

Kotlin 1.7 was released in June 2022, including the alpha version of the new Kotlin K2 compiler.[25]

Kotlin 1.8 was released in December 2022, 1.8.0 was released on January 11, 2023.[26]

Kotlin 1.9 was released in July 2023, 1.9.0 was released on July 6, 2023.[27]

## Design

Development lead Andrey Breslav has said that Kotlin is designed to be an industrial-strength object-oriented language, and a "better language" than Java, but still be fully interoperable with Java code, allowing companies to make a gradual migration from Java to Kotlin.[28]

Semicolons are optional as a statement terminator; in most cases a newline is sufficient for the compiler to deduce that the statement has ended.[29]

Kotlin variable declarations and parameter lists have the data type come after the variable name (and with a colon separator), similar to Ada, BASIC, Pascal, TypeScript and Rust. This, according to an article from Roman Elizarov, current project lead, results in alignment of variable names and is more pleasing to eyes, especially when there are a few variable declarations in succession, and one or more of the types is too complex for type inference, or needs to be declared explicitly for human readers to understand.[30][31]

Variables in Kotlin can be read-only, declared with the val keyword, or mutable, declared with the var keyword.[32]

Class members are public by default, and classes themselves are final by default, meaning that creating a derived class is disabled unless the base class is declared with the open keyword.

In addition to the classes and member functions (which are equivalent to methods) of object-oriented programming, Kotlin also supports procedural programming with the use of functions.[33] Kotlin functions and constructors support default arguments, variable-length argument lists, named arguments, and overloading by unique signature. Class member functions are virtual, i.e. dispatched based on the runtime type of the object they are called on.

Kotlin 1.3 added support for contracts,[34] which are stable for the standard library declarations, but still experimental for user-defined declarations. Contracts are inspired by Eiffel's design by contract[35] programming paradigm.

Kotlin code may be compiled to JavaScript, allowing for interoperability between code written in the two languages. This can be used either to write full web applications in Kotlin, or to share code between a Kotlin backend and a JavaScript frontend.[36]

## Syntax

### Procedural programming style

Kotlin relaxes Java's restriction of allowing static methods and variables to exist only within a class body. Static objects and functions can be defined at the top level of the package without needing a redundant class level. For compatibility with Java, Kotlin provides a `JvmName` annotation which specifies a class name used when the package is viewed from a Java project. For example, `@file:JvmName("JavaClassName")`.

### Main entry point

Main article: Entry point

As in C, C++, C#, Java, and Go, the entry point to a Kotlin program is a function named "main", which may be passed an array containing any command-line arguments. This is optional since Kotlin 1.3.[37] Perl, PHP, and Unix shell–style string interpolation is supported. Type inference is also supported.

// Hello, World! example
fun main() {
val scope = "World"
println("Hello, $scope!")

fun main(args: Array<String>) {
for (arg in args)
println(arg)

### Extension functions

Similar to C#, Kotlin allows adding an extension function to any class without the formalities of creating a derived class with new functions. An extension function has access to all the public interface of a class, which it can use to create a new function interface to a target class. An extension function will appear exactly like a function of the class and will be shown in code completion inspection of class functions. For example:

package MyStringExtensions

fun String.lastChar(): Char = get(length - 1)

>>> println("Kotlin".lastChar())

By placing the preceding code in the top-level of a package, the String class is extended to include a `lastChar` function that was not included in the original definition of the String class.

// Overloading '+' operator using an extension function
operator fun Point.plus(other: Point): Point {
return Point(x + other.x, y + other.y)

>>> val p1 = Point(10, 20)
>>> val p2 = Point(30, 40)
>>> println(p1 + p2)
Point(x=40, y=60)

### Unpack arguments with spread operator

Similar to Python, the spread operator asterisk (*) unpacks an array's contents as individual arguments to a function, e.g:

fun main(args: Array<String>) {
val list = listOf("args: ", *args)
println(list)

### Destructuring declarations

Destructuring declarations decompose an object into multiple variables at once, e.g. a 2D coordinate object might be destructured into two integers, x and y.

For example, the `Map.Entry` object supports destructuring to simplify access to its key and value fields:

for ((key, value) in map)
println("$key: $value")

### Nested functions

Kotlin allows local functions to be declared inside of other functions or methods.

class User(val id: Int, val name: String, val address: String)

fun saveUserToDb(user: User) {
fun validate(user: User, value: String, fieldName: String) {
require(value.isNotEmpty()) { "Can't save user ${user.id}: empty $fieldName" }

validate(user, user.name, "Name")
validate(user, user.address, "Address")
// Save user to the database
...

### Classes are final by default

In Kotlin, to derive a new class from a base class type, the base class needs to be explicitly marked as "open". This is in contrast to most object-oriented languages such as Java where classes are open by default.

Example of a base class that is open to deriving a new subclass from it:

// open on the class means this class will allow derived classes
open class MegaButton {

// no-open on a function means that
//    polymorphic behavior disabled if function overridden in derived class
fun disable() { ... }

// open on a function means that
//    polymorphic behavior allowed if function is overridden in derived class
open fun animate() { ... }

class GigaButton: MegaButton() {

// Explicit use of override keyword required to override a function in derived class
override fun animate() { println("Giga Click!") }

### Abstract classes are open by default

Abstract classes define abstract or "pure virtual" placeholder functions that will be defined in a derived class. Abstract classes are open by default.

// No need for the open keyword here, it’s already open by default
abstract class Animated {

// This virtual function is already open by default as well
abstract fun animate()

open fun stopAnimating() { }

fun animateTwice() { }

### Classes are public by default

Kotlin provides the following keywords to restrict visibility for top-level declaration, such as classes, and for class members: `public`, `internal`, `protected`, and `private`.

When applied to a class member:

Keyword | Visibility

|

`public` (default) | Everywhere
`internal` | Within a module
`protected` | Within subclasses
`private` | Within a class

When applied to a top-level declaration:

Keyword | Visibility

|

`public` (default) | Everywhere
`internal` | Within a module
`private` | Within a file

Example:

// Class is visible only to current module
internal open class TalkativeButton {
// method is only visible to current class
private fun yell() = println("Hey!")
// method is visible to current class and derived classes
protected fun whisper() = println("Let's talk!")

internal class MyTalkativeButton: TalkativeButton() {
fun utter() = super.whisper()

MyTalkativeButton().utter()

### Primary constructor vs. secondary constructors

Kotlin supports the specification of a "primary constructor" as part of the class definition itself, consisting of an argument list following the class name. This argument list supports an expanded syntax on Kotlin's standard function argument lists that enables declaration of class properties in the primary constructor, including visibility, extensibility, and mutability attributes. Additionally, when defining a subclass, properties in super-interfaces and super-classes can be overridden in the primary constructor.

// Example of class using primary constructor syntax
// (Only one constructor required for this class)
open class BaseUser(open var isSubscribed: Boolean)
open class PowerUser(protected val nickname: String, final override var isSubscribed: Boolean = true):BaseUser(isSubscribed) { }

However, in cases where more than one constructor is needed for a class, a more general constructor can be defined using secondary constructor syntax, which closely resembles the constructor syntax used in most object-oriented languages like C++, C#, and Java.

// Example of class using secondary constructor syntax
// (more than one constructor required for this class)
class Context
class AttributeSet
open class View(ctx:Context) {
constructor(ctx: Context, attr: AttributeSet): this(ctx)

class MyButton : View {
// Constructor #1
constructor(ctx: Context) : super(ctx) {

// Constructor #2
constructor(ctx: Context, attr: AttributeSet) : super(ctx, attr) {
// ...

### Sealed classes

Sealed classes and interfaces restrict subclass hierarchies, meaning more control over the inheritance hierarchy.

Declaration of sealed interface and class:

sealed interface Expr
sealed class Job

All the subclasses of the sealed class are defined at compile time. No new subclasses can be added to it after the compilation of the module having the sealed class. For example, a sealed class in a compiled jar file cannot be subclassed.

sealed class Vehicle
data class Car(val brandName: String, val owner: String, val color: String): Vehicle()
class Bike(val brandName: String, val owner: String, val color: String): Vehicle()
class Tractor(val brandName: String, val owner: String, val color: String): Vehicle()
val kiaCar = Car("KIA", "John", "Blue")
val hyundaiCar = Car("Hyundai", "Britto", "Green")

### Data classes

Kotlin's `data class` construct defines classes whose primary purpose is storing data. This construct is similar to normal classes except that the key functions `equals`, `toString`, and `hashCode` are automatically generated from the class properties. In Java, such classes are expected to provide a standard assortment of functions including those.[clarification needed] Data classes are not required to declare any methods, though each must have at least one property. A data class often is written without a body, though it is possible to give a data class any methods or secondary constructors that are valid for any other class. The `data` keyword is used before the `class` keyword to define a data class.[38]

// data class with parameters and their optional default values
data class Book(val name: String = "", val price: Int = 0)
fun main(args: Array<String>) {
// create a data class object like any other class object
var book1 = Book("Kotlin Programming", 250)
println(book1)
// output: Book(name=Kotlin Programming, price=250)

### Kotlin interactive shell

$ kotlinc-jvm
type :help for help; :quit for quit
>>> 2 + 2

>>> println("Hello, World!")
Hello, World!

### Kotlin as a scripting language

Kotlin can also be used as a scripting language. A script is a Kotlin source file using the .kts filename extension, with executable source code at the top-level scope:

// list_folders.kts
import java.io.File
val folders = File(args[0]).listFiles { file -> file.isDirectory() }
folders?.forEach(::println)

Scripts can be run by passing the `-script` option and the corresponding script file to the compiler.

$ kotlinc -script list_folders.kts "path_to_folder_to_inspect"

### Null safety

Kotlin makes a distinction between nullable and non-nullable data types. All nullable objects must be declared with a "?" postfix after the type name. Operations on nullable objects need special care from developers: a null-check must be performed before using the value, either explicitly, or with the aid of Kotlin's null-safe operators:

* ?. (the safe navigation operator) can be used to safely access a method or property of a possibly null object. If the object is null, the method will not be called and the expression evaluates to null. Example:

>     // returns null if...
>     // - foo() returns null,
>     // - or if foo() is non-null, but bar() returns null,
>     // - or if foo() and bar() are non-null, but baz() returns null.
>     // vice versa, return value is non-null if and only if foo(), bar() and baz() are non-null
>     foo()?.bar()?.baz()

* ?: (the null coalescing operator) is a binary operator that returns the first operand, if non-null, else the second operand. It is often referred to as the Elvis operator, due to its resemblance to an emoticon representation of Elvis Presley.

>     fun sayHello(maybe: String?, neverNull: Int) {
>         // use of Elvis operator
>         val name: String = maybe ?: "stranger"
>         println("Hello $name")
>     }

### Lambdas

Kotlin provides support for higher-order functions and anonymous functions, or lambdas.[39]

// the following function takes a lambda, f, and executes f passing it the string "lambda"
// note that (String) -> Unit indicates a lambda with a String parameter and Unit return type
fun executeLambda(f: (String) -> Unit) {
f("lambda")

Lambdas are declared using braces, { }. If a lambda takes parameters, they are declared within the braces and followed by the -> operator.

// the following statement defines a lambda that takes a single parameter and passes it to the println function
val l = { c : Any? -> println(c) }
// lambdas with no parameters may simply be defined using { }
val l2 = { print("no parameters") }

### Complex "hello world" example

fun main(args: Array<String>) {
greet {
to.place
}.print()

// Inline higher-order functions
inline fun greet(s: () -> String) : String = greeting andAnother s()

// Infix functions, extensions, type inference, nullable types,
// lambda expressions, labeled this, Elvis operator (?:)
infix fun String.andAnother(other : Any?) = buildString()

append(this@andAnother); append(" "); append(other ?: "")

// Immutable types, delegated properties, lazy initialization, string templates
val greeting by lazy { val doubleEl: String = "ll"; "he${doubleEl}o" }

// Sealed classes, companion objects
sealed class to { companion object { val place = "world"} }

// Extensions, Unit
fun String.print() = println(this)

## Tools

* Android Studio (based on IntelliJ IDEA) has official support for Kotlin, starting from Android Studio 3.[40]
* Integration with common Java build tools is supported, including Apache Maven,[41] Apache Ant,[42] and Gradle.[43]
* Emacs has a Kotlin Mode in its MELPA package repository.
* JetBrains also provides a plugin for Eclipse.[44][45]
* IntelliJ IDEA has plug-in support for Kotlin.[46] IntelliJ IDEA 15 was the first version to bundle the Kotlin plugin in the IntelliJ Installer, and to provide Kotlin support out of the box.[47]

## Applications

When Kotlin was announced as an official Android development language at Google I/O in May 2017, it became the third language fully supported for Android, after Java and C++.[48] As of 2020[update], Kotlin is the most widely used language on Android, with Google estimating that 70% of the top 1,000 apps on the Play Store are written in Kotlin. Google itself has 60 apps written in Kotlin, including Maps and Drive. Many Android apps, such as Google Home, are in the process of being migrated to Kotlin, and therefore use both Kotlin and Java. Kotlin on Android is seen as beneficial for its null-pointer safety, as well as for its features that make for shorter, more readable code.[49]

In addition to its prominent use on Android, Kotlin is gaining traction in server-side development. The Spring Framework officially added Kotlin support with version 5, on 4 January 2017.[50] To further support Kotlin, Spring has translated all its documentation to Kotlin, and added built-in support for many Kotlin-specific features such as coroutines.[51] In addition to Spring, JetBrains has produced a Kotlin-first framework called Ktor for building web applications.[52]

In 2020, JetBrains found in a survey of developers who use Kotlin that 56% were using Kotlin for mobile apps, while 47% were using it for a web back-end. Just over a third of all Kotlin developers said that they were migrating to Kotlin from another language. Most Kotlin users were targeting Android (or otherwise on the JVM), with only 6% using Kotlin Native.[53]

## Adoption

In 2018, Kotlin was the fastest growing language on GitHub, with 2.6 times more developers compared to 2017.[54] It is the fourth most loved programming language according to the 2020 Stack Overflow Developer Survey.[55]

Kotlin was also awarded the O'Reilly Open Source Software Conference Breakout Award for 2019.[56]

Many companies / organizations have used Kotlin for backend development:

* Allegro[57]
* Amazon[58]
* Atlassian[59]
* Cash App[60][61]
* Flux[62]
* Google[63]
* Gradle[64]
* JetBrains[65]
* Meshcloud[66]
* Norwegian Tax Administration[67]
* OLX[68]
* Pivotal[69]
* Rocket Travel[70]
* Shazam[71]
* Zalando[72]

Some companies / organizations have used Kotlin for web development:

* Barclay's Bank[73]
* Data2viz[74]
* Fritz2[75]
* JetBrains[76]

A number of companies have publicly stated they were using Kotlin:

* Basecamp[77]
* Corda, a distributed ledger developed by a consortium of well-known banks (such as Goldman Sachs, Wells Fargo, J.P. Morgan, Deutsche Bank, UBS, HSBC, BNP Paribas, and Société Générale), has over 90% Kotlin code in its codebase.
* Coursera[78]
* DripStat[79]
* Duolingo[80]
* Netflix[81]
* Pinterest[82]
* Trello[83]
* Uber[84]

## See also

* Comparison of programming languages

## References

* This article contains quotations from Kotlin tutorials which are released under an Apache 2.0 license.

1. ↑ "What is the correct English pronunciation of Kotlin?". 16 October 2019. https://discuss.kotlinlang.org/t/what-is-the-correct-english-pronunciation-of-kotlin/2050.
2. ↑ "kotlin-stdlib". JetBrains. https://kotlinlang.org/api/latest/jvm/stdlib/index.html.
3. ↑ "Kotlin for JavaScript - Kotlin Programming Language" (in en). https://kotlinlang.org/docs/reference/js-overview.html.
4. ↑ "Kotlin for cross-platform mobile development" (in en). https://www.jetbrains.com/lp/mobilecrossplatform/.
5. ↑ "Kotlin Foundation - Kotlin Programming Language". https://kotlinlang.org/foundation/kotlin-foundation.html.
6. ↑ 6.0 6.1 Lardinois, Frederic (7 May 2019). "Kotlin is now Google's preferred language for Android app development" (in en-US). https://techcrunch.com/2019/05/07/kotlin-is-now-googles-preferred-language-for-android-app-development/.
7. ↑ "Kotlin FAQ". https://kotlinlang.org/docs/faq.html#which-versions-of-jvm-does-kotlin-target. Retrieved 2023-04-02. "Kotlin lets you choose the version of JVM for execution. By default, the Kotlin/JVM compiler produces Java 8 compatible bytecode. If you want to make use of optimizations available in newer versions of Java, you can explicitly specify the target Java version from 9 to 19. Note that in this case the resulting bytecode might not run on lower versions."
8. ↑ "Stability of Kotlin Components". May 21, 2021. https://kotlinlang.org/docs/components-stability.html.
9. ↑ "Kotlin 1.5.0 – the First Big Release of 2021". 4 May 2021. https://blog.jetbrains.com/kotlin/2021/05/kotlin-1-5-0-released/.
10. ↑ 10.0 10.1 Krill, Paul (22 July 2011). "JetBrains readies JVM language Kotlin". https://www.infoworld.com/d/application-development/jetbrains-readies-jvm-based-language-167875.
11. ↑ Waters, John (22 February 2012). "Kotlin Goes Open Source". 1105 Enterprise Computing Group. https://adtmag.com/articles/2012/02/22/kotlin-goes-open-source.aspx.
12. ↑ Mobius (8 January 2015), Андрей Бреслав — Kotlin для Android: коротко и ясно, https://www.youtube.com/watch?v=VU_L2_XGQ9s, retrieved 28 May 2017
13. ↑ Kieron Murphy (4 October 1996). "So why did they decide to call it Java?". https://www.javaworld.com/article/2077265/core-java/so-why-did-they-decide-to-call-it-java-.html.
14. ↑ Merriam-Webster (2023-06-08). "Java Definition & Meaning". https://www.merriam-webster.com/dictionary/java.
15. ↑ "Why JetBrains needs Kotlin". https://blog.jetbrains.com/kotlin/2011/08/why-jetbrains-needs-kotlin/. "we expect Kotlin to drive the sales of IntelliJ IDEA"
16. ↑ "test · JetBrains/kotlin@3e4dce3" (in en). https://github.com/JetBrains/kotlin/commit/3e4dce385331c91c9059fcdcea3eae2394f34942.
17. ↑ "Kotlin 1.0 Released: Pragmatic Language for JVM and Android | Kotlin Blog". 15 February 2016. https://blog.jetbrains.com/kotlin/2016/02/kotlin-1-0-released-pragmatic-language-for-jvm-and-android/.
18. ↑ Shafirov, Maxim (17 May 2017). "Kotlin on Android. Now official". https://blog.jetbrains.com/kotlin/2017/05/kotlin-on-android-now-official/. "Today, at the Google I/O keynote, the Android team announced first-class support for Kotlin."
19. ↑ "Kotlin 1.2 Released: Sharing Code between Platforms | Kotlin Blog". 28 November 2017. https://blog.jetbrains.com/kotlin/2017/11/kotlin-1-2-released/.
20. ↑ "Multiplatform Projects - Kotlin Programming Language". https://kotlinlang.org/docs/reference/multiplatform.html. "Working on all platforms is an explicit goal for Kotlin, but we see it as a premise to a much more important goal: sharing code between platforms. With support for JVM, Android, JavaScript, iOS, Linux, Windows, Mac and even embedded systems like STM32, Kotlin can handle any and all components of a modern application."
21. ↑ "Kotlin/kotlin-full-stack-application-demo". Kotlin. 3 April 2020. https://github.com/Kotlin/kotlin-full-stack-application-demo.
22. ↑ "Kotlin full stack app demo: update all involving versions to work with 1.3.70 release". https://youtrack.jetbrains.com/issue/KT-37029.
23. ↑ "Kotlin 1.1 Released with JavaScript Support, Coroutines and more". https://blog.jetbrains.com/kotlin/2017/03/kotlin-1-1/.
24. ↑ "What's New in Kotlin 1.4 - Kotlin Programming Language" (in en). https://kotlinlang.org/docs/reference/whatsnew14.html. "In 1.4.0, we slightly change the Swift API generated from Kotlin with respect to the way exceptions are translated."
25. ↑ "What's new in Kotlin 1.7.0 | Kotlin" (in en-US). https://kotlinlang.org/docs/whatsnew17.html.
26. ↑ Paul Krill (2023-01-12). "Kotlin 1.8.0 adds recursive copy, delete for directories" (in en). https://www.infoworld.com/article/3682130/kotlin-180-adds-recursive-copy-delete-for-directories.html. Retrieved 2022-03-08.
27. ↑ Sarah Haggarty (2023-07-06). "Kotlin 1.9.0 Released" (in en). https://blog.jetbrains.com/kotlin/2023/07/kotlin-1-9-0-released/. Retrieved 2023-07-06.
28. ↑ "JVM Languages Report extended interview with Kotlin creator Andrey Breslav". 22 April 2013. https://zeroturnaround.com/rebellabs/jvm-languages-report-extended-interview-with-kotlin-creator-andrey-breslav/.
29. ↑ "Semicolons". https://confluence.jetbrains.com/display/Kotlin/Grammar#Grammar-Semicolons.
30. ↑ "Types are moving to the right". 16 July 2020. https://elizarov.medium.com/types-are-moving-to-the-right-22c0ef31dd4a#:~:text=Woot! That’s nice and aligns, pleasure for our eyes to see..
31. ↑ "Roman Elizarov is the new Project Lead for Kotlin". JetBrains. https://blog.jetbrains.com/kotlin/2020/11/roman-elizarov-is-the-new-project-lead-for-kotlin/.
32. ↑ "Basic Syntax". Jetbrains. https://kotlinlang.org/docs/reference/basic-syntax.html#defining-variables.
33. ↑ "functions". https://confluence.jetbrains.com/display/Kotlin/Functions.
34. ↑ "What's New in Kotlin 1.3 - Kotlin Programming Language". https://kotlinlang.org/docs/reference/whatsnew13.html.
35. ↑ "Design by Contract (DbC) design considerations" (in en-US). 16 August 2012. https://discuss.kotlinlang.org/t/design-by-contract-dbc-design-considerations/1321. "Implement the full semantics of Eiffel DbC and improve upon it."
36. ↑ "Kotlin for JavaScript | Kotlin" (in en-US). 21 January 2021. https://kotlinlang.org/docs/js-overview.html#use-cases-for-kotlin-js.
37. ↑ "Kotlin Examples: Learn Kotlin Programming By Example". https://play.kotlinlang.org/byExample/01_introduction/01_Hello world.
38. ↑ "Introduction to Data Classes in Kotlin". https://www.callicoder.com/kotlin-data-classes/.
39. ↑ "Higher-Order Functions and Lambdas". Jetbrains. https://kotlinlang.org/docs/reference/lambdas.html.
40. ↑ "Kotlin and Android". https://developer.android.com/kotlin.
41. ↑ "Using Maven – Kotlin Programming Language". https://kotlinlang.org/docs/reference/using-maven.html.
42. ↑ "Using Ant – Kotlin Programming Language". https://kotlinlang.org/docs/reference/using-ant.html.
43. ↑ "Using Gradle – Kotlin Programming Language". https://kotlinlang.org/docs/reference/using-gradle.html.
44. ↑ "Getting Started with Eclipse Neon – Kotlin Programming Language". 10 November 2016. https://kotlinlang.org/docs/tutorials/getting-started-eclipse.html.
45. ↑ "JetBrains/kotlin-eclipse: Kotlin Plugin for Eclipse". GitHub. https://github.com/JetBrains/kotlin-eclipse.
46. ↑ "Kotlin :: JetBrains Plugin Repository". 31 March 2017. https://plugins.jetbrains.com/plugin/6954-kotlin.
47. ↑ "What's New in IntelliJ IDEA 2017.1". https://www.jetbrains.com/idea/whatsnew/.
48. ↑ Lardinois, Frederic (17 May 2017). "Google makes Kotlin a first-class language for writing Android apps" (in en-US). https://techcrunch.com/2017/05/17/google-makes-kotlin-a-first-class-language-for-writing-android-apps/.
49. ↑ "Kotlin programming language: How Google is using it to squash the code bugs that cause most crashes". https://www.zdnet.com/article/google-were-using-kotlin-programming-language-to-squash-the-bugs-that-cause-most-crashes/.
50. ↑ "Introducing Kotlin support in Spring Framework 5.0". Pivotal. 4 January 2017. https://spring.io/blog/2017/01/04/introducing-kotlin-support-in-spring-framework-5-0.
51. ↑ "The State of Kotlin Support in Spring" (in en). https://blog.jetbrains.com/kotlin/2020/08/the-state-of-kotlin-support-in-spring/.
52. ↑ "Review of Microservices Frameworks: A Look at Spring Boot Alternatives". https://dzone.com/articles/not-only-spring-boot-a-review-of-alternatives.
53. ↑ "Kotlin Programming - The State of Developer Ecosystem 2020" (in en). https://www.jetbrains.com/lp/devecosystem-2020/kotlin/.
54. ↑ "The state of the Octoverse". https://octoverse.github.com/projects.
55. ↑ "Stack Overflow Developer Survey 2020". https://insights.stackoverflow.com/survey/2020#most-loved-dreaded-and-wanted.
56. ↑ "Kotlin wins Breakout Project of the Year award at OSCON '19". https://blog.jetbrains.com/kotlin/2019/07/kotlin-wins-breakout-project-of-the-year-award-at-oscon-19/.
57. ↑ "Kotlin at Allegro" (in en). https://talkingkotlin.com/kotlin-at-allegro/.
58. ↑ "QLDB at Amazon". https://talkingkotlin.com/qldb/.
59. ↑ "Future of Jira Software powered by Kotlin". https://www.youtube.com/watch?v=4GkoB4hZUnw.
60. ↑ "Going Full Kotlin Multiplatform" (in en). https://talkingkotlin.com/going-full-kotlin-multiplatform/.
61. ↑ "square/sqldelight". https://github.com/square/sqldelight.
62. ↑ "Using Kotlin for backend development at Flux" (in en). https://talkingkotlin.com/Using-Kotlin-for-backend-development-at-Flux/.
63. ↑ "State of Kotlin on Android". https://www.youtube.com/watch?v=AgPj1Q6D--c&feature=youtu.be&t=309.
64. ↑ "Gradle Kotlin DSL Primer". https://docs.gradle.org/current/userguide/kotlin_dsl.html.
65. ↑ "Kotless" (in en). https://talkingkotlin.com/kotless/.
66. ↑ "Kotlin on the backend at Meshcloud" (in en). https://talkingkotlin.com/kotlin-on-the-backend-at-meshcloud/.
67. ↑ "KotlinConf 2019: Kotlin Runs Taxes in Norway by Jarle Hansen & Anders Mikkelsen". https://www.youtube.com/watch?v=K8XxaAba65g&list=PLQ176FUIyIUY6SKGl3Cj9yeYibBuRr3Hl&index=22.
68. ↑ "Greenfield Kotlin at OLX" (in en). https://talkingkotlin.com/greenfield-kotlin-at-olx/.
69. ↑ "Application Monitoring with Micrometer" (in en). https://talkingkotlin.com/application-monitoring-with-micrometer/.
70. ↑ "Groovy and Kotlin Interop at Rocket Travel" (in en). https://talkingkotlin.com/groovy-and-kotlin-interop-at-rocket-travel/.
71. ↑ "Kotlin at Shazam" (in en). https://talkingkotlin.com/kotlin-at-shazam/.
72. ↑ "Zally - An API Linter" (in en). https://talkingkotlin.com/Zally-An-API-Linter/.
73. ↑ "Java/Kotlin Developer - Barclays - Prague - Wizbii" (in en). https://www.wizbii.com/company/barclays/job/convertibles-trading-system-developer.
74. ↑ "KotlinConf 2017 - Frontend Kotlin from the Trenches by Gaetan Zoritchak". https://www.youtube.com/watch?v=1Pu0TYJJ2Tw&list=PLQ176FUIyIUY6UK1cgVsbdPYA3X5WLam5&index=14.
75. ↑ "Fritz2" (in en). 14 September 2020. https://talkingkotlin.com/fritz2/.
76. ↑ "KotlinConf 2019: Kotlin in Space by Maxim Mazin". https://www.youtube.com/watch?v=JnmHqKLgYY4.
77. ↑ "How we made Basecamp 3's Android app 100% Kotlin – Signal v. Noise". Signal v. Noise. 29 April 2017. https://m.signalvnoise.com/how-we-made-basecamp-3s-android-app-100-kotlin-35e4e1c0ef12.
78. ↑ "Becoming bilingual@coursera". 26 April 2018. https://medium.com/coursera-engineering/becoming-bilingual-coursera-d8048dce73e3.
79. ↑ "Kotlin in Production – What works, Whats broken". 24 September 2016. https://blog.dripstat.com/kotlin-in-production-the-good-the-bad-and-the-ugly-2/.
80. ↑ "Duolingo on Twitter". https://twitter.com/duolingo/status/1247876630984474626.
81. ↑ "Rob Spieldenner on twitter". https://twitter.com/robspieldenner/status/708355228832178176.
82. ↑ "Droidcon NYC 2016 - Kotlin in Production". https://www.youtube.com/watch?v=mDpnc45WwlI.
83. ↑ "Dan Lew on Twitter". https://twitter.com/danlew42/status/809065097339564032.
84. ↑ "2017 Who's using Kotlin?". 7 February 2017. https://www.reddit.com/r/androiddev/comments/5sihp0/2017_whos_using_kotlin/ddfmkf7/.

## External links

* v
* t
* e

Programming languages

* Comparison
* Timeline
* History

* APL
* Assembly
* BASIC
* C
* C++
* C#
* COBOL
* Elixir
* Fortran
* Go
* Groovy
* Haskell
* Java
* JavaScript (JS)
* Julia
* Kotlin
* Lisp
* Lua
* MATLAB
* Objective-C
* OCaml
* Pascal
* Perl
* PHP
* Python
* R
* Ruby
* Rust
* Scala
* Shell
* Smalltalk
* Swift
* TypeScript
* Visual Basic .NET (VB.NET)
* more...

* Category
* Lists
* Alphabetical
* Categorical
* Generational
* Non-English-based

* v
* t
* e

Java

Platforms|

* Java language
* JVM
* Micro Edition
* Standard Edition
* Enterprise Edition
* Java Card
* Android SDK

Oracle technologies|

* Squawk
* Java Development Kit
* OpenJDK
* Java virtual machine
* JavaFX
* Maxine VM

Platform technologies|

* Applets
* Servlets
* MIDlets
* JSP
* JSF
* Web Start (JNLP)

Major third-party technologies|

* Blackdown
* Eclipse
* GNU Classpath
* GWT
* Harmony
* Hibernate
* IcedTea
* Jazelle
* Spring
* Struts
* TopLink
* WildFly

History|

* Java version history
* Java Community Process
* Sun Microsystems
* Free Java implementations

Major JVM languages|

* BeanShell
* Clojure
* Groovy
* JRuby
* Jython
* Kotlin
* Processing
* Rhino
* Scala

Community|

| Conferences|

* JavaOne
* Devoxx

|

Organizations|

* Apache Software Foundation
* Java Community Process
* Oracle Corporation
* Sun Microsystems, Sun Microsystems Laboratories

People|

* James Gosling
* Arthur van Hoff
* Urs Hölzle
* Patrick Naughton

Category

0.00

(0 votes)

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Kotlin_(programming_language)&oldid=3906768"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template