Android Development with KOTLIN

Aman Mishra
Department of Computer Science and Engineering
Arya College of Engineering and IT
Jaipur , India

Abstract:-- Java programming language is a widely used language Interoperability

for the development of Android applications. However recent Interoperability is the most outstanding feature in Kotlin‟s
research proves that this language suffers from certain drawback magic box one can call a code written in Java to Kotlin and
which is the main reason for the crashes of Android applications. vice-versa. There is no need to convert the entire project into
This has paved the way for other alternative languages like
Kotlin from the very beginning.
Groovy, Scala, Kotlin, etc.. All the other languages mentioned
above have their own demerits like Groovy suffers from un safety
whereas Scala generates steep learning curve. But Kotlin can be Freedom from Null Pointer Exceptions
used widely instead of Java almost everywhere and its usage We need not be afraid of Null Pointer Exceptions, because
can be widely seen in Android applications development, Kotlin takes NULL value checks from runtime to compile
Server-side development and much more. Our research work time which means that Null safety is a part of the system
analyses how Kotlin can be integrated with the existing Java itself. All variables are non-null in Kotlin,.
language. The experimental results prove that this new
programming language can reduce the compilation time, Lesser verbosity
execution time and can increase conciseness when integrated with Kotlin helps us to write concise and crisp code to help save
Java.
ample time and decrease the boilerplate & clustering. The
Keywords:-- Programming language, Android applications, programmer to gest rid of the worrying task of adding
Kotlin semicolons after every statement. This helps in increasing
productivity code as well as saves time.
1. INTRODUCTION
Smart Casts
The goal of this paper is to give an overview of the Kotlin The coder need not worry about explicitly casting operators
language and it‟s wide support in developing Android because Kotlin‟s compiler inserts casts automatically
applications,Server side applications and much more.The wherever needed.
paper is also meant to address the significant portions where
Java lacked and why Kotlin is going to take over Java Destructuring Declarations
real soon.It also discusses about Conciseness ,Interoperability Multiple variables for an object are declared at a stretch.
and productivity which are the major things kept in mind
when working on any Android project.To get a proper overview Awesome IDE and Plugin support
of Kotlin let us start the discussion with the features where Java To get Kotlin install a simpleplugin in Android Studio or
lacks. even in Eclipse .
To convert our existing Java code to Kotlin we have an
amazing plugin “Convert Java file to Kotlin”

II. DISADVANTAGES OF JAVA

Java – an unsafe language

Null Pointer Exception, also referred to as “THE BILLION
DOLLAR MISTAKE” is one of the well-known drawback of
Java.Every other day another security loop hole peeps up in
Java that everybody struggles with.Everyone wants clean
and simple code, which is self-understandable and easily read
by others also, but Java makes it cumbersome to organize
code in a concise way. One of the biggest drawbacks of Java
is that writing huge sections of code even for the smallest of
tasks,. And at last, it turns out to be a pain for the coders with
innumerous lines of codes .

The main reason how Kotlin stands out in the ocean of

programming languages is that it improves over Java‟s
limitations and positively affects day to day development
workflow. It is incredibly powerful and has a handful of
things which would attract any coder.
All Rights Reserved © 2017 IJSEM 271
 ISSN (Online) 2456 -1304

var a: String = "abc"

III. IS KOTLIN PERFECT a = null // compilation error
We can declare a variable as nullable string, written String? :
Though Kotlin seem to be the most promising one it to allow nulls
also have some flaws. var b: String? = "abc"
b = null // ok
Sluggish compilation
The compilation speed which is fairly less than its 2. Java Interop
competitive languages is a minor drawback of Kotlin . Both Java and Kotlin files can be used within the same
project. In Java projects we can use Kotlin libraries and vice
Small developer community versa. The usage of Java and Kotlin classes simultaneously in
For the time being Kotlin still has a small developer the project eliminates the need for full project conversion or
community despite its rapid adoption among coders. having to start a project from the beginning. A key factor behind
the rising adoption rate of Kotlin is it‟s
Larger package size Interoperability with Java .
The package size of Kotlin is bigger in size as compared to In a natural way existing Java code can be called from
Java. Kotlin, and rather smoothly as well Kotlin code can be used
from Java. We shall describe some details about calling Java
Java to Kotlin code from Kotlin.
Around 80% of the Java code converts to Kotlin might be a
boon seamlessly. The remaining 20% of the code import java.util.*
gets thoroughly scrambled and can be too tedious to resolve. fun demo(source: List<Int>) {
val list = ArrayList<Int>()
IV. TASTE OF KOTLIN for(item in source) {list.add(item)}
for(i in 0..source.size - 1) {
A new modern programming language, KOTLIN is much list[i] = source[i] }}
suited for all kinds of Multiplatform applications in today‟s
world. The above code shows that Kotlin behaves very well in the
existing Java ecosystem in terms of the usage of Java
This language is well suited to supercharge your Android libraries, provides Java APIs, and integration with Java
development. Kotlin replaces the very old JAVA which frameworks.
suffers from the “Billion Dollar Mistake” i.e. NULL Kotlin mostly through extensions but sometimes with
POINTER EXCEPTION, the main cause for Android compiler-supported techniques (primitives, arrays,
Applications crashes. To be said precisely it finds its usage collections) relies on Java libraries. This gets us compatibility
widely instead of JAVA almost everywhere today .KOTLIN while keeping the language clean.
stands for it‟s - 100% interoperability with JAVA,
application reliability , pragmatic nature, rich availability of 3. Checked Exceptions
standard library, safe, tool friendliness, concise and the list The compiler in Kotlin does not force you to catch any of the
goes on and on. We shall now explore Kotlin‟s main features exceptions which means all exceptions are unchecked. So,
in a detailed manner . Kotlin does not force you to do anything when you call
a Java method that declares a checked exception,:
V. SIGNIFICANT FEATURES OF KOTLIN
fun render(list: List<*>, to: Appendable) {
1. Null Safety for (item in list) {to.append(item.toString()) }}
Nullable types and Non-Null Types
Kotlin's type system eliminates the danger of null references 4. Object Methods
from code, also called as the The Billion Dollar Mistake. In Kotlin all the references of the type java.lang.Object are
The type system helps us to differentiate between references turned into Any when Java types are imported into Kotlin.
that can hold null and those that cannot. Because Any is not platform-specific, it declares only
As an example, consider a regular variable of type equals() , hashCode() and toString() as its members, so to
String which cannot hold null: make other members of java.lang.Object available, Kotlin
uses extension functions.

All Rights Reserved © 2017 IJSEM 272

 ISSN (Online) 2456 -1304

example consider the Address class that contains all data

5. Translation of type nothing associated with a particular address:
Since the type Nothing has no natural counterpart in Java it is
special. Infact, every reference type in Java, accepts null as a public class Address {
value, and nothing doesn't even accept that. So in the Java private String street;
world this type cannot be accurately represented. Hence private String city;
Kotlin includes a raw type where an argument of type private int streetNumber;
Nothing is used: private String postCode;
private Country country; }
fun emptyList(): List<Nothing> = listOf() …
// is translated to
// List emptyList() { ... } The above class is less searchable and less readable. So
generate an immutable Address class which contains only
6. Speed of Compilation getters but no setters pretty fast with a modern IDE.Here of
With tests revealing that Java is still the „faster‟ language – at Kotlin‟s major advantage is readability Kotlin‟s code is
an average, ~13% faster compilation speeds (with Gradle) much clearer.
than Kotlin (14.2 seconds vs 16.6 seconds). Now for partial
builds with incremental compilation, the speed advantage of Now let‟s have a look at the similar class in Kotlin:
Java more or less disappears, with Kotlin either being at par, or
even just a bit faster,. data class Address(var street: String,
To be more precise clean builds are perfomed more quickly in var streetNumber: Int,
Java but the two languages are alike for partial builds. var postCode: String,
var city: String,
7. Execution Time & Verbosity var country: Country)
Generally the volume of coding in Java is considerably
greater than in Kotlin. To be said Kotlin is a more compact Instead we shall now create an immutable
lanaguage . The Kotlin Android Extensions, data class using the val keyword instead of var and ensure
facilitates references to be quickly imported inside Activity that all the objects you pass in are immutable as well:
files (within Views) – and then, as part of the Activity that
View can be used in the code which means the coders need not data class Address(val street: String,
re-write the „findViewByld‟ method for each case.Since val streetNumber: Int,
this feature is not seen in Java the amount of boilerplate code val postCode: String,
is a lot greater than that in Kotlin. To use the Kotlin val city: String,
extensions simply add an additional plugin in the build.gradle val country: Country)
file. The third-party dependency injection tools are not at all
needed in Kotlin unlike Java. In Kotlin, var creates mutable variables whereas val is used to
create immutable variables.
Automatic conversion of Java to Kotlin
The Java to Kotlin converter integrated with IntelliJ helps us b. Smart Casts
save a huge amount of time. It saves you from retyping the There are often many situations in Java, where we often
code. Migrating code from Java to Kotlin without it would have to cast objects in the place of the compiler which could
take much longer. actually do this for us because it‟s clear that the object can be
cast. Consider the following example:
7. Conciseness
Concise and Expressive syntax is the one of the major selling public class Cast {
points of Kotlin . This is accomplished with the four ways static void printString(String str) {
discussed below. System.out.println(str); }

a. Data Classes public static void main(String[] args) {

Without much additional functionality sometimes we create Object hello = "Hello, World!";
classes which act simply as data containers in Java. For if (hello instanceof String) {
printString((String) hello);} } }

All Rights Reserved © 2017 IJSEM 273

 ISSN (Online) 2456 -1304

Kotlin makes this even easier. By convention, Kotlin creates an

The Java compiler would throw us an error if we have tried to implicit parameter called “it” so that you can skip typing the
change printString((String) hello) to just printString(hello parameter for lambda expressions with only one
because hello is of type Object. parameter,:
The compiler thus could prove us that a actual parameter is
hello for the formal parameter , str of printString(String str): fun main(args: Array<String>) {
val genres = listOf("Action", "Comedy", "Thriller")
fun printString(str: String) { val myKindOfMovies = genres.filter{ it.length> 6 }.map {
println(str) } it + " Movie" }
println(myKindOfMovies)
fun main(args: Array<String>) { }
val hello: Any = "Hello, World!"
if (hello is String) { Here there is actually another convention here. Whenever
printString(hello) }} the last parameter of a method is a lambda expression, we
can put it behind the parentheses of the method call.
Any type in Kotlin is the equivalent of Java‟s Object, In the previous example, both lambda expressions are the
similar to “is” is the equivalent of instanceOf, and that only parameters so that you can skip the parentheses
enables us to create package-level functions in Kotlin .This is altogether.
known as Smart Casts in Kotlin. Also, the myKindOfMovies variables now stores an
. Whenever the compiler can prove that typecasting an Iterable<String> there is no need for us to use a collect()
object is safe appropriately, it will: method at the end,. This can also be made explicit if we want
to:
// Smart cast #1
if (hello !is String) return val myKindOfMovies: Iterable<String> = genres.filter{
printString(hello) // Smart cast it.length> 6 }.map { it + " Movie" }

// Smart cast #2 d. Objects as Singletons

if (hello is String &&hello.first().isLetter()) { // Smart cast To create a singleton though there are many ways, let‟s look
after && at the most common way to create it in Java:
println("The string starts with a letter")
} public class Singleton {
private static Singleton theInstance= new
In smart cast #1, it is obvious that hello must be a string. Singleton();
Otherwise due to the return statement in the preceding line
the control flow wouldn‟t even reach that point. private Singleton() { }
Smart casts #2 make use of lazy evaluation.
public static Singleton getInstance() {
c.Functional Programming returntheInstance; } }
Kotlin comes with functional capabilities baked in much
similar to Java 8 which introduced functional language A class with a private constructor was created such that we
elements such as lambda expressions (function literals),. can control which instances of it are created. Because we
Look at the usage of function literals in Java 8: would like to have only one object of this class at any point of
time, we shall instantiate it as a private attribute and allow
public static void main(String[] args) { retrieving it from the outside using getInstance().
List<String> genres = Arrays.asList("Action", "Comedy",
"Thriller"); By using the object keyword in Kotlin, we can create such a
List<String>myKindOfMovies = genres.stream().filter(s - singleton in a single line:
>s.length() > 6).map(s -> s + " object KotlinSingleton {}
Movie").collect(Collectors.toList()); Just like you may do it for a singleton in Java such object
System.out.println(myKindOfMovies); // Output: declarations in Kotlin are initialized lazily,.
[Thriller Movie] } This approach can nearly even keep up with the conciseness of
Kotlin.

All Rights Reserved © 2017 IJSEM 274

 ISSN (Online) 2456 -1304

CONCLUSION

Kotlin makes Android programming easy to learn and lot

more interesting.Though it has some of the drawbacks, it
helps us to save ample amount of time in a much neater and
helpful way.

I hope this paper gave you some more understanding of the

Kotlin programming language and how it handles some of
the more annoying aspects of Java in more convenient ways.
Kotlin‟s syntax is generally rather concise which makes your
code more readable and thus maintainable.

All Rights Reserved © 2017 IJSEM 275