The new island (source: Laci Németh, software engineer)

Initially, programming happened in the cumbersome language of binary, a series of 0s and 1s. Those programs only ran on a specific hardware type, it was difficult for a person to understand the codes built of several tiny elements, so during the beginning years it was easy to make mistakes while programming and if you had to modify an existing program there were a quite a few risks involved.

Then in the 50s, the first high-level programming languages (Fortran, Lisp, and Algol) were produced. On the one hand, these languages were detached from the hardware and thus codes became more similar to the English language. On the other hand, their abstractions enabled the program to be more clearly, intelligibly and transparently formulated. Programs written in high-level languages could be translated into the low-level language (machine code) of different kinds of hardware.

Later, in the early 70s, C was released, followed by C ++ a decade later. They soon became the most popular programming languages.

C was developed by Dennis Ritchie who rewrote the Unix operating system using this language. Object-oriented C ++ was Bjarne Stroustrup’s merit. In Object orientated programming (OOP) we describe the relevant properties and internal logic of existing things, processes, and events for a particular application in the “classes” of the appropriate language. During the application runtime, copies of these classes called “objects”, interact with each other, modeling the operation of a part of reality in quite a lifelike way. C and C ++ codes could be translated onto different hardware and operating systems and so could be run on them, but you needed the source code for the translation and in many cases, it needed to be adjusted to the target runtime environment.



Another decade had passed and Sun Microsystems had created a new language and also a layer between the language and the hardware plus operating system base. This new intermediate layer became the Java Virtual Machine (JVM), which enabled a program written or inverted in any environment to run in any other environment without any modification or recompiling. The oriented language of the new object compiling to JVM was named Java.

Sun then dusted an old idea off to incorporate it into JVM, this was the “garbage collection”.

It meant that programs could work with data for which memory areas were reserved. After use, these would be freed up again otherwise there would be no free memory after some time and the program would fail, and send an error message. The release of non-used memory pieces was often forgotten by the developer, so a “memory leak” was a rather frequent problem. When Sun with JVM brought out the automatic memory release, the garbage collection, a whole profession started to breathe easier.


Java became the world’s most popular programming language in no time as it seemed to be a much more simplified version of C ++. Java ecosystem has since grown enormously and is ready to offer a solution for almost everything.

Yet, no matter how capable it seemed to be, Java was not able to rule all existing platforms. It became popular mostly in international corporate servers, locked away from the outside world and rich in resources (CPUs, memory). Moreover, it could not conquer the terrain of browser security which is a security-sensitive area. Meanwhile, global systems like Amazon, Google and Facebook were developed, which, despite of their abundant computing capacity, could not have served the world with Java-based software. With the last big waves of information technology, smarter and smarter mobile phones have arrived and so did IoT, the Internet of things. These tools typically don’t have high resources, so this terrain was beneficial for languages that compile to machine language. So, time has passed over Java.

In around 2008 JetBrains, a Russian software development tool builder team, was looking for a solution to this situation, so they could remedy their own Java-based development difficulties. First, they examined other existing languages, but none of them proved to be completely satisfactory. The team from St. Petersburg wanted a pragmatic, unambiguous, concise code that would save them from commonplace programming mistakes. They summed up all the features they desired in a language and they started to develop their own programming language that they named after Kotlin Island, an island close to St. Petersburg. Kotlin now not only runs in JVM along with the existing Java code but also in browsers and soon it is going to run on small embedded hardware as well.

Although the world noticed it slowly, this summer Google announced that from this year Kotlin along with Java, would be an Android supported language. This means that the new language will spread quick as a flash on the largest mobile platform in the world. In the era of the Internet of Things we will also be able to run the Kotlin code on small embedded hardware, what’s more, JetBrains want Kotlin to conquer browsers next.

Why is all of this good for customers? Currently a “full stack” (frontend, backend, and mobile) developer needs to know several languages but they usually only know one really well. With Kotlin, it will be soon possible to program faster and more safely in each layer (frontend, backend, and mobile) and when you have an existing Java project you won’t have to translate it all back into Kotlin, it can be done part by part, or you can easily modify it by attaching new parts written in Kotlin. Maintenance is also simplified with Kotlin. If the developer acquires an existing code they can easily interpret it and they can modify or expand it more safely. Overall, I think Kotlin-based development will be faster and safer, and Kotlin-based systems will be manageable and improvable and more efficiently than ever before.

It will be a great choice for our customers.