Kotlin vs. Swift: Are Android and iOS moving towards creating a universal language?
Tags: mobiledevelopment, ios, kotlin, swift
Published: 2017-08-22 18:54:05

---
title: "Kotlin vs. Swift: Are Android and iOS moving towards creating a universal language?"
published: true
description: Comparing Kotlin with Swift. Can these languages trigger the appearance of a universal mobile development language for both Android and iOS?
tags: mobile development, iOS, Kotlin, Swift
---
![alt text](https://thepracticaldev.s3.amazonaws.com/i/1ckvhgs9qeq92xdaqjas.png "Kotlin vs. Swift")

Once Kotlin received Google’s support, the sheer excitement of Kotlin fans wasn’t the only reaction to follow. Those not familiar with Kotlin were quite concerned about its compatibility/interoperability level with Java, the average time necessary to get the hang of it, as well as the [advantages of using Kotlin] (https://www.scnsoft.com/blog/kotlin-development-what-you-need-to-know-about-androids-new-official-language) in general.

In their attempts to explain and introduce the language in the shortest and clearest way possible, many Kotlin developers referred to a 3-year-old parallel between Kotlin and the second official language of iOS – Swift. Calling Kotlin “the Swift of Android” did make things easier and helped to create an image for the language. Yet this image also provoked [arguments] (https://blog.mosheberman.com/swift-is-not-like-kotlin/) in the iOS community, as some iOS developers didn’t find the comparison flattering and saw Kotlin as a mere copycat.

At the very least, it should be noted that while Swift appeared in 2013, Kotlin originated back in 2011. Hence, even though comparing Kotlin to Swift (in this exact order) can be convenient due to Swift’s earlier introduction to a wide audience, any â€˜copycat’ attitudes towards Kotlin aren’t justified. 
Still, does the comparison stand? If yes, how far does the similarity stretch? And does its existence hint at the fact that delivering apps for both iOS and Android natively can become easier and faster in the future? ScienceSoft's huge experience in [mobile app development services] (https://www.scnsoft.com/services/mobile-app-development) allows to speculate at this point. Let’s look into it.

## Syntax

The syntax of Swift doesn’t just resemble that of Kotlin: in small chunks of code there can be up to [77% string similarity] (http://angelolloqui.com/blog/38-Swift-vs-Kotlin-for-real-iOS-Android-apps). Major differences can be reduced to the table below:

| Kotlin        | Swift         | 
| ------------- |:-------------:| 
| fun      | func | 
| val      | let      |  
| null | nil      |   
| trait      | protocol | 
| constructor      | init      |  
| : | ->      |   
| Any      | AnyObject      |  
| !! | !      |   

Basics, classes and functions all have very similar ways of expression. Unlike Objective-C’s, Swift’s method calls are similar to those of Java and Kotlin, with their namespace system and dot-notation style. For example, here’s what function call looks like in the two languages:

| Kotlin        | Swift         | 
| ------------- |:-------------:| 
| fun forecast(day: String, weather: String): String {      | func forecast(_ day: String, _ weather: String) -> String { | 
|     return "Today is $day, it's $weather."      |     return "Today is \\(day), it's \\(weather)."      |  
| } | }      |   
| forecast("Monday", "Raining")      | forecast("Monday", "Raining") | 

And this is how classes are declared in both:

| Kotlin        | Swift         | 
| ------------- |:-------------:| 
| class Residence {      | class Residence { | 
|     var numberOfRooms = 0      |     var numberOfRooms = 0      |  
|     fun Description() = |     func Description() -> String {      |   
|         "A house with $numberOfRooms."      |         return "A house with \\(numberOfRooms)." | 
| }      | }      | 
|       | }      | 

Many other examples can be found in this [article] (http://nilhcem.com/swift-is-like-kotlin/), and if they tell us something, it is that both languages share the initial purpose of staying as concise and transparent as possible, making lives of developers easier. Kotlin’s and Swift’s syntax systems are quite effective in that regard, as they are appreciated by development teams for their elegancy. 

## Security

Although both Swift and Kotlin are strong and static in terms of typing, they also allow work with dynamic types. This way, the languages stay concise and flexible, while allowing early elimination of bugs and mismatches. Therefore, they are considered highly secure and especially reliable for big projects.
Apart from that, the two languages combine approaches to handling optional values and null/nil safety with either Safe Navigation Operator ? or Option types. The ? precaution is expressed in almost the same manner in both Kotlin and in Swift:

| Kotlin        | Swift         | 
| ------------- |:-------------:| 
| val example: String? = null      | var example: String? = nil | 

## Features

Besides null (nil) safety, functions and classes, Kotlin and Swift have multiple similar features, including *constants, variables, generics, protocols (traits), enumerated types, any (anyobject), error handling* and others. Some of the features implemented in the two languages share the approach, but are called differently due to the original language these features go back to.

For instance, in Kotlin one can find Java’s **lambda** expressions (which, by the way, are highly effective but aren’t available for Java Android development). In Swift these are **blocks** or **closures**, the terms from Objective-C. The way both expressions are called into code is as similar, as the way they work.

| Kotlin        | Swift         | 
| ------------- |:-------------:| 
| {      | { _in | 
|     println("Lambda Expression")     |     print("Closure Expression") |
| }      | } |

The feature known as **computed properties** in Swift, which is a specific property declaration with a â€˜get’ call, is enabled in Kotlin as well:

| Kotlin        | Swift         | 
| ------------- |:-------------:| 
| class Animal(      | class Animal { | 
|     var Genus: String,         |     var Genus : String      |  
|     var Species: String) {   |     var Species : String      |   
|     val binomialName: String      |     var binomialName: String { | 
|             get() = "$Genus $Species"         |             get {      |  
|     }   |                 return "\\(Genus) \\(Species)"      |   
|           |             } | 
|           |     } | 
|           |     } | 

**Name parameters** (or named arguments) are also used in both languages:

| Kotlin        | Swift         | 
| ------------- |:-------------:| 
| fun daysoff(vacation: Int, weekends: Int): Int = vacation + weekends      | func daysoff(vacation: Int, weekends: Int) -> Int { | 
|       |   return vacation + weekends      |  
|  | }      |   
| daysoff(5, weekends = 8)      | daysoff(vacation: 5, weekends: 8) | 

In fact, instead of listing the features that exist in both languages, it would be easier to list those that don’t. Namely, only Kotlin supports: 
-	class import, 
-	primary constructors and data classes, 
-	@annotations.

At the same time, unlike Kotlin, Swift has:
-	tuples, 
-	typealias, 
-	guard statement.

## Meaning behind similarities

The two languages clearly share the ideology, as they solve the same problems created by their ancestor languages: they are less verbose and limited in functions, more readable and convenient to work with. At the same time, both Kotlin and Swift stay interoperable with Java and Objective-C respectively, which allows using them in new projects as well as in maintenance of old ones.

What’s more, the strong resemblance of the two languages can aid in native development of one app for both iOS and Android. This isn’t to say the apps on both platforms can share one code, of course, since the languages and OS-specific libraries aren’t identical. Still, the approaches to application logic and functionality can be very similar, thanks to syntactical and functional similarity between Swift and Kotlin. This can make development, testing and maintenance faster and easier.

## Universal language for iOS and Android?

In theory, Google could have already accepted Swift as its official language instead of Kotlin; there were even rumors surrounding this possibility back in 2016. Such a move might have not created a situation where any cross-platform development tools became irrelevant, but the margin between the two platforms would have certainly become blurry.

However, such a step would have also been unreasonable, and not just because of business competitiveness. Although Swift and Kotlin are similar, what they resemble most are their predecessors. In other words, Swift and Kotlin are bridging the gap between Objective-C and Java. Yet a shift from Java to Kotlin is still more natural and smooth than that from Java to Swift.

In general, the thought of adjusting to something new doesn’t appeal to everyone; some developers take their time to give a new language a go, just like it was with the [adoption of Swift] (https://www.scnsoft.com/blog/why-you-should-consider-developing-your-ios-app-on-swift). To make sure the transition would be less of an ordeal means ensuring the language will eventually catch on, and for a new language it is the first and foremost.

## Parting thought

As mobile development constantly evolves, so does technology. That’s why in 5-10 years both Kotlin and Swift can become something entirely different. There is no telling whether the languages will continue to bridge the gap between each other. Still, as both iOS and Android are searching for the most convenient, secure and fast mobile development tool, they just might end up speaking the same language one day.