Swift VS Kotlin

This article will briefly discuss the definition of these programming languages, as well as some comparisons in syntax, styles, and implementations. Whether you are a beginner iOS programmer, an experienced programmer in other programming languages, or just want to get up to speed, this article will be helpful.


Let's first tackle Kotlin



Kotlin arrived in 2016 and was introduced by JetBrains and Google; it has been widely used and liked by the programming community. It is a language that runs on JVM and is interoperable with Java. This was officially released for use in Android development in 2017. It requires a good knowledge of Java.


Now let's talk about Swift


Swift is the one of choice for the iOS developer community at the moment. It is used for iOS apps, macOS apps, watchOS apps, and tv apps.


This language was designed by Chris Lattner to improve the also known Objetive-C.


This programming language is excellent in terms of compatibility with devices that run this code such as mobile devices, desktop servers, among others.


Swift has libraries with a large set of predefined methods. These allow easy use to structure the logic which makes it simpler to write the code as well as its maintenance.


Both programming languages are interoperable with their predecessors. If we take into account that when developing a native application, we need to develop it for each operating system, it is important to make this comparison to simplify the process.


Basic types

Syntax

Switch case

Swift:

var x = 3
switch x {
   case 1: print("x == 1")
   case 2, 4: print("x == 2 or x == 4")
   default: print("x is something else") 
}

Kotlin

val x = 3
when (x) {
   1 -> print("x == 1")
   2, 4 -> print("x == 2 or x == 4")
   else -> print("x is something else")
}

String interpolation

Swift

var name = "Johan"
print("Hello \(name)")

The string can also be generated in the format:

let str = NSString(format:"%d , %f, %ld, %@", 1, 1.5, 100, "Hello World")
print(str)

Kotlin

var name = "Johan"
println("Hello $name")

if you want to specify the format:

val str = String.format("%d, %f, %d, %s", 1, 1.5, 100, "Hello World")
print(str)


Function and Closure

The Swift function has an argument label:

func someFunction(argumentLabel parameterName: Int) {
   // In the function body, parameterName refers to the argument value
   // for that parameter.
}

while parameterName is used within the function, argumentLabel is used by the caller.

When a reasoning label is not given, parameterName also plays the role of argumentLabel.


If you do not want to detail a reasoning label in the least, the reasoning label can be suppressed using underscore _.


Closure

The closure is similar to lambda in Kotlin.

A simple example in Swift:

let sayHello = { (name: String) -> String in
    let result = "Hello \(name)"
    print(result)
    return result
}
sayHello("Johan")


Same in Kotlin

val sayHello : (String) -> String = { name: String ->
   val result = "Hello $name"
   print(result)
   result
}
sayHello("Johan")


Common:


The type can be deduced from the context.

They can be passed as reasonings as a factor of another function to obtain nested functions (higher-order functions).


if the closure/lambda is the last factor, we can put it outside the parentheses of the function. if it is the only factor, we do not need to write parentheses().


Differences:


In Swift, only the closure of a single expression can suppress the return keyword; In Kotlin, the last expression is going to be treated as the return value, with no return keyword in lambda.

Swift has abbreviated reasoning names such as $0, $1, $2.


Custom types



Class


The Swift and Kotlin class looks quite similar.


Inheritance is used: and the function of the subclass could override the function of the superclass.


There is an ordering requirement: the class must come before any protocol.


The only thing different is the constructor, quickly it is the initializer:


class Person {
   let name: String
   init(name: String = "") {
       self.name = name
   }
}
let p1 = Person()
print("\(p1.name)") // default name: ""
let p2 = Person(name: "xxxx")
print("\(p2.name)")


In Kotlin, we could achieve the same result by typing this:


class Person(val name: String = "") {
}
val p1 = Person()
print("${p1.name}") // default name: ""
val p2 = Person(name="xxxx")
print("${p2.name}")


and in Kotlin, the class can have a init {} block to assist with further initialization work


Struct


Struct is a type of value.

struct vs. Class:


  • The class can be inherited.
  • Struct is a value type, copies will not share data; class is the reference type, and all copies will share the same instance.
  • The class has deinit.
  • The class instance can be let, and can change the var class property.


class Person {
   var name = "Lian"
}
let p1 = Person()
p1.name = "Sarah"
print("\(p1.name)")


And if the person is a struct, it would look like this:


struct Person {
   var name = "Lian"
}
let p1 = Person()
p1.name = "Sarah"
// Compiler error: Cannot assign to property: `p1` is a `let` constant

In structure we also have to use: we have to use **var** p1 = Person().


Protocol


The protocol is interface in Kotlin.

We can define a function and properties as contracts.


The properties may become:


protocol SomeProtocol {
   var mustBeSettable: Int { get set }
   var doesNotNeedToBeSettable: Int { get }
}

There are slight differences in the protocol and the interface, such as that the class that incorporates the protocol does not need to use the override keyword in functions.


Extension

The extension is different in both Swift and Kotlin. In Swift it is used to store functions and properties while in Kotlin it is the top-level method adding the type before:


fun String.someMethod() : String {
   return this.trim()
}

In swift:

extension String {
   func trimmed() -> String {
       self.trimmingCharacters(in: .whitespacesAndNewlines)
   }
  
   mutating func trim() {
       self = self.trimmed()
   }
  
   var lines: [String] {
       self.components(separatedBy: .newlines)
   }
}

Enum

In Swift it would be:

enum CompassPoint {
   case north
   case south
   case east
   case west
}

And separated by a comma:

enum Planet {
    case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
}

The type can be discarded using the dot syntax:

var directionToHead = CompassPoint.west
directionToHead = .east

Kotlin

enum class Direction {
   NORTH, SOUTH, WEST, EAST
}

With enum, you can define properties and functions for both Kotlin and Swift


Main differences between Swift and Kotlin in a nutshell


  1. Swift enumerations are considered more powerful than those in Kotlin
  2. There is no data class in Swift
  3. Missing classes and delegated properties in Swift
  4. No annotations are allowed in Swift
  5. All classes in Kotlin are final by default
  6. Kotlin does not have a prop or pass-by-value data
  7. Kotlin does not provide Tuple
  8. Kotlin does not have a type alias
  9. Kotlin does not have a guard declaration


Summary and recommendations


Kotlin is a programming language for Android application development, and Swift is for IOS application development. Both Kotlin vs. Swift languages were built on the modern programming approach. Both Swift and Kotlin incorporate several features defined in a long list of libraries. These programming languages are not restricted to mobile application development but server-side development and cross-platform applications using different frameworks available.


In any case, if you want to develop a native mobile application MCSS framework will be of great help as it is developed simultaneously in SWIFT and JAVA so that programmers can apply the stylesheets in iOS and Android applications.


MCSS is a powerful tool that will help you to develop 100% native applications reducing development time and production costs.


To learn more about MCSS visit it at MCSS


Bibliography



“About Swift — The Swift Programming Language (Swift 5.7).” Documentation, https://docs.swift.org/swift-book/. Accessed 8 September 2022.

Chugh, Anupam. “Swift vs. Kotlin: The Similarities and Differences You Should Know.” Better Programming, 6 May 2020, https://betterprogramming.pub/swift-vs-kotlin-the-similarities-and-differences-you-should-know-b2f1be201888. Accessed 8 September 2022.

Guide, Step. “How to use Kotlin for back end development.” Quokka Labs, 9 August 2021, https://quokkalabs.com/blog/how-to-use-kotlin-for-back-end-development/. Accessed 8 September 2022.