Java is the most handy language for the Android developers for building apps. it also very user-friendly on the other hand, it increases the productivity of the developers with new methods and libraries.but, the productivity and the ease of coding as to improved with time to compete with advance technology.And, here comes the kotlin in the picture after Google started supporting kotlin.

In the year 2017, Google announced that they will be using Kotlin as the official language for Android.Most of the Android developers were pleased by the move as they knew that shifting from core Java to user-friendly and more sophisticated Kotlin is a big relief.The easy coding environment with a number of support with reusable libraries and also productivity tools made developers to compare it with the Swift.







However, most of the iOS developers believe that Kotlin is none other than the copycat of Swift.but, the thing is that Kotlin is in the industry since from 2011 whereas Apple introduced the Swift in 2013.Although there are some differences between Swift and Kotlin when it comes to crafting an app, and there is nothing like a copycat.Even though there was some similarities, there are major differences among these two programming language that every developer should know about.
 Besides, if both the language does some common things, so how long the similarities stretch?

Even though having different environment to run and access to totally different libraries, both Swift and Kotlin have similar Syntax.

Syntax Similarities


The syntax of each Swift and Kotlin are similar up to a significant extent. during a group of small functions, you'll realize variety of similar strings. Below you'll find the main difference between the syntax of the two programming languages.


KotlinSwift
funfunc
vallet
nullnil
traitprotocol
constructorinit
:->
AnyAnyObject
!!!

Class declaration



KotlinSwift
class Resisdence {class Resisdence {
var numberOfRooms = 0var numberOfRooms = 0
fun Description() =func Description() -> String {
"A house with $numberOfRooms."return "A house with \(numberOfRooms)."
}}
}




Similarities that matters

Data Class 

In Kotlin you'll see the data class, whereas the Swift passes on it. during the code, we frequently create classes, whose primary function is to hold the data. generally these classes also mechanically drive standard functionalities and utility functions. These classes are referred to as data classes in Kotlin. However, in Swift, you will not find any counterparts of data classes.


// Comment
data class User(val name: String, val age: Int)

Enums are the key

Enums is the term used to declare the enumerations in the coding, and it contains the set of name constraints known as enum list. Swift offers very powerful first class-type enums that are used to do the features of the struct, computed properties and totally different values depending on per case. Kotlin misses the enums that lack the results of enums pattern whereas coding due to language limitations. However, such a pattern are often achieved by sealed class, however that will be very sophisticated.


// Comment
example with type: enum Gender: String{ case Male case Female }

example without type: enum Gender { case Male case Female }

Structs

In Kotlin there's no specific type of structs for the developers to use, the language is the same as the Java. Besides, there are few types of structs like int, boolean, float that required to be passed by value, and remaining are passed by the reference. On the opposite hand in Swift, you get the liberty to choose the type of struct you preferred for your data.


struct User { var username: String var email: String var name: String }

Tuples

A Tuples is an ordered set of values, or it can be defined as a structured data having the multiple parts. In relational database the information is stored in the form of spreadsheet where the tuples are often taken as the rows. The tuples are useful in defining the interaction between components where you do not have additional classes. sadly, Kotlin does not have any Tuples types or expressions whereas Swift leverages it to define the interfaces among components.


var TupleName = (Value1, value2,… any number of values)


var error501 = (501, “Not implemented”)


print(“The code is\(error501.0)”)


print(“The definition of error is\(error501.1)”)


var error501 = (errorCode: 501, description: “Not Implemented”)


print(error501.errorCode) // prints 501.

Delegated class and properties

The delegated properties are the most appreciated attribute of Kotlin that offers an additional point to it against Swift. The delegated properties allow the developers to automatically forward citations of methods to different classes. Besides, the delegated properties additionally allow to define the behavior of common properties including lazy properties, observation properties, and storing properties. However, Swift does not provide this characteristic, therefore you have to be glad with the properties provided by default.


class Example { var p: String by Delegate() }

Memory Management

Both Swift and Kotlin uses the different memory management approach wherever Kotlin uses the garbage collection approach on the opposite hand Swift goes for Automatic References counting or ARC. Honestly speaking Swift memory management approach works higher than Kotlin because it is additional reliable and precise.

Annotations

Where Kotline offers support for a number of annotations, Swift doesn't support any of them. Annotations are the most efficient way for adding metadata to the code. you simply need to write the annotation modifier in front of the class. the different annotations Kotlin supports includes the @Taget, @Repeatble, @Retention, @MustBeDocumented.


@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION,

AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION)

@Retention(AnnotationRetention.SOURCE)

@MustBeDocumented

annotation class Fancy

Here some difference between Kotlin and Swift in coding:

Hello World


KotlinSwift
print("Hello, world!")println("Hello, world!")

Functions


KotlinSwift
func greet(_ name: String,_ day: String)-> String { return "Hello \(name), today is \(day)." } greet("Bob", "Tuesday") fun greet(name: String, day: String): String { return "Hello $name, today is $day." } greet("Bob", "Tuesday")

Tuple Return


KotlinSwift
func getGasPrices() -> (Double, Double, Double) { return (3.59, 3.69, 3.79) }data class GasPrices(val a: Double, val b: Double, val c: Double) fun getGasPrices() = GasPrices(3.59, 3.69, 3.79)

With the above codes, you'll clearly see that both the languages share a inevitable similarities in their coding pattern. In 2016 was a rumors that Google may choose Swift as the official language for android however that did not happen. Considering the Kotlin and Swift similarities the move could be possible. However, at a similar time choosing Swift rather than Kotlin can be inappropriate. That’s not simply because of Apple and Google being rivals however shifting from Java to Kotlin is much smoother than Java to Swift. although Swift and Kotlin are very similar and somehow both the languages are bridging the gap between Objective-C and Java.

What is SwiftKotlin?

SwiftKotlin is an open source tool or framework for mac computers that automatically translates the Swift codes to Kotlin. The developers need to paste the code Swift into the tool, and it'll get converted into Kotlin. However, there are another alternatives for building a multi-platform project and exchange the code between these two languages. React Native, Cordova, X, Mandarin and other low-level libraries can be used for the same purpose, however SwiftKotlin holds many benefits over these.

Conclusion

The mobile app development industry is continuously evolving, and therefore the introduction of new tool changes everything overnight. there's no guarantee if in the coming 7 to 10 years both iOS and android app development changes entirely. both the platforms are looking for stable, additional convenient, and faster app development tool. So, perhaps eventually both the platforms end up accepting a better common framework or tool by filling the gap between them.

0 comments:

Post a Comment

 
Kotlin Guide © 2013. All Rights Reserved. Powered by Blogger
Top