Ten Years of Kotlin: The Story of The Programming Language

Ten Years of Kotlin: The Story of The Programming Language

Show Video

In 2011, JetBrains conceived the  idea for a programming language  that would make development  more productive and enjoyable. Today, Kotlin is one of the most loved and fastest growing programming languages in the world. It's used by millions of developers for all sorts of projects. Including multiplatform, mobile,  server-side, web and cloud  development, data science and machine learning. Kotlin has been used to make  some really great things.

In fact, it's surprising how extensively it's integrated into our everyday lives. Almost every internet user has come across Kotlin software. If you have an Android phone or tablet - about 80% of the apps you use were built with Kotlin. And it's reach extends beyond this platform. Kotlin code can run on virtually any device.

And it's under the hood of  the services we use daily. For communicating, learning,  searching for information, banking - streaming video, commuting, playing games, automating our cars and more. The story of Kotlin is wonderful and exciting. Kotlin's ten year journey started with an idea. The idea of creating something that would make development more fun. And maybe even make this world a better place.

We have always relied on  input from our community when  making decisions about the  future of the technology. Over the last ten years, Kotlin  has accumulated millions of changes  based on feedback from thousands  of Kotlin users around the world. In a few moments, you will hear from the people who created Kotlin and use it everyday. They will talk about how the spirit and simplicity of the language have been preserved. While it has grown in ten  years, from a start-up project  inside JetBrains, to an  entire technology ecosystem.

With hundreds of contributors offering their perspectives and input. It happened very incidentally. And the story is that, our founder and CEO back then Sergey Dmitriev - asked a bunch of guys: "Guys, what do you  think JetBrains can do in terms of the  big things that would benefit the community  and going to be noticeable?", you know? And Dmitry Jemerov - one of the engineers in the company back then - said: "The ultimate  thing   a development company can do for the development community is a programming language."

I was thinking at the time that  JetBrains was a company that was  building tools for languages and  technologies from other companies. Languages and frameworks and so on. And I was thinking of  possible ways to increase the  influence of JetBrains in  the community - so to say. Like how can we do something  that is our own technology  and not just supporting other peoples' technology. We had a lot of experience building  support for different languages.

Starting with Java and then others - Javascript, Ruby, Python, PHP, Scala and so on. And I thought... That maybe we could use that experience, we could use our knowledge of the - Twenties of different languages - their   advantages and disadvantages - to maybe build our own programming language. And you know, immediately everyone was laughing, because, you know - Really? A programming language? We are kind of a small company with you know - We have made a few very successful projects - like IntelliJ IDEA and ReSharper, but... But a programming language is a different league altogether - it's big, it's huge. And it was like that for a  couple of days, but then - The seed was there, and we started  thinking: "Well we have a deep  understanding of many programming  languages and their practical aspects."

You know, we've implemented  support for a dozen - or maybe  twenty - a couple of dozen programming languages. And we know all of the drawbacks and good things in many languages. So we can combine the things which are good and practical and many people would use it. So, we started it.

When I first heard that it was going to be a general purpose language on the JVM - I was like "No way, there's no  point in creating a new language.  It's completely unreasonable, there  are good languages out there". At the moment Scala was pretty big and I liked it. And it felt like all the  problems that existed on the  JVM at the moment were more  or less solved by Scala. And I was like:   "Just don't do it. It's not a good idea. Just use Scala and you'll be fine." But then the conversation went  on and I was starting to think: "  OK, it is sensible - there are  issues that are not solved yet".

And also, their point was that  JetBrains is in - a position -  a very good position to put  a new language out there. And attract enough attention, and get traction and get users and so on and so forth. And that was this "Aha!" moment  when I thought: "OK, so this  is still a crazy idea, but it makes sense. We have a shot at doing something really good." Initially, the name was simply "Jet". It was quite straightforward that JetBrains is working on the language "Jet".

But we discovered that this name  was taken - just the trademark  was taken already. So we had  to come up with something else. We were looking for another name and didn't like anything. It was quite difficult.

At some point, Dmitry Jemerov suggested that we call the language "Kotlin". For an island that is out  there near Saint Petersburg. And the logic was: by that time we had already heard about the language "Ceylon". And they have a nice pun:   'Java' is the coffee island and 'Ceylon' is the tea island. So there was this progression of islands, and it was a nice idea to use a local name. So, we made the initial announcement at the JVM language summit in 2011.

Which was on the Oracle campus in Santa Clara. Their reaction was quite positive, so - They understood what we are doing,  they understood the scope  of our effort, and they - Seemed to like what we are doing and to see this  as a credible way to move  forward with the language. This was a nice expression of support for us. In 2011, I happened to be in  the same room when "Kotlin" -  the programming language  was announced by JetBrains. Andrey Breslaw and Dmitry  Jemerov were presenting it. And I thought: "Oh, it's a  nice language. It has all those 

nice features. It has an approach to nullability." But, it was the time when Java was about to get lambdas in the language. So I thought that if Java gets lambdas, I don't need the other languages for JVM. "Why do we need Kotlin -  this looks similar to Scala."

"Oh, why do we need Kotlin if Java has said they're going to do this." And, "Yeah, I don't really  see the benefit of a Kotlin." And there was obviously a bunch of people also that were saying "This is cool", right? So there was a lot of naysayer,  but there was also a lot  of people that were inspired and interested in it. Somebody was asking someone on the internet whether Kotlin works on Android. So, our answer was: "Well  we didn't try it on Android. 

You definitely should. It should work." The first time I heard about  Kotlin was, I think, in early 2013. And my initial reaction was actually pretty negative towards it. And then I had forgotten about  it for about two years, when we  took a look at it again for  potential use for our Android app. And the language had evolved  a ton over those two years.

And had become something that was much more familiar to those coming from Java and - At a time where the Java language was relatively  stagnant, Kotlin really felt  like a breath of fresh air. And allowed us to pull in a bunch  of concepts into our Android app,  that we otherwise, potentially, wouldn't  have been able to use for a couple of years. The language pretty much blew everyone away. Now only we were getting - you know  - these features that we wanted - But also it came with a bunch of thing that we didn't know that we really needed. You can really see and understand the Kotlin team's philosophy.

In the code, in the center library, in the different - you know - tools that we have. You know, the idea of like readability, and re-usability, interoperability, And also just the great tooling. I can think in a Kotlin'y way and I can see how that Kotlin'y thinking comes from the team - And then flows through the language  and the libraries and the features and  down to me - and, hopefully,  you know - I work within them. I think it has forced me to be a more thoughtful developer. It's really just like what we are  trying to build - rather than -  less so how we are building  it and how our syntax is. In that sense, Kotlin   really does kind of - you know - quicken and improve my code quality.

And hopefully, my ability to communicate concepts  and ideas and build things  for my teammates to use. I think it made me a better developer to be perfectly honest with you. The Kotlin community is  passionate, is warm, is welcoming - I've actually seen the  proof of this so many times.

I got to interact with  developers all around the world. And they were all like this - they were all passionate and warm and welcoming. It's just incredible seeing so many developers supporting each other and growing together.

Community that really helps newcomers learn. And then, eventually, those newcomers are the ones that are helping others. And I think it's critical  to keep a community healthy. And to listen to the community and to help the community. Because without the community you don't have anything. Like, especially, with something like a language.

You will not have anything without a community. So, the success of Kotlin is  language, tooling, whatever  you want it, but it's also,  greatly, the community. I do remember the first  "Online Community" of Kotlin. We had an IRC channel. And it was myself, Ilya Ryzhenkov, Justin Lee, and I think a couple of other people would show up. Like, maximum there was four or five - Once in a while someone would  pop-in and they were like:  "Oh, no - wrong channel" and they  would leave the channel, right? And it was the same as Twitter, like - We were searching for Twitter - every time Kotlin would come up we were like: "No, no it's the ketchup. They  are looking at the ketchup."

"Oh no, they're looking at the town." "No, they're looking for the island." "Oh look - someone is asking something about this language." It was a discussion that Max and I had, and we were talking and - We were like: "Maybe it's time  to do a Kotlin conference to  welcome the community and  bring the community together - Show people that Kotlin is here to stay." I was saying: "Maybe we should target like three hundred people." And Max was like: "No, more!" "OK, maybe five hundred." And he's like: "A thousand."

And I'm like: "A thousand people?!" "I don't think we're going to be able to get a thousand people." And he was like: "No, we will be able to." And sure enough we did. We actually - in the first KotlinConf we got  one thousand two hundred  people I believe, if not - Yeah, one thousand two hundred people.

And we were sold out. I went to many conferences. And Kotlin was very welcomed - especially by the Android community.

I met many enthusiastic folks who tried Kotlin - And used it even before the stable release - even before the 1.0 version. And the most popular question at that time was "When does Kotlin finally become stable?" And after the release, the most  popular question transformed  into the question about the  official Google position. Kotlin and Android happened because there were top  engineers in the team and  they were using the language.

The language was so great. And the team that was looking at it really drove  that point home and said  "Look, we got to do this." Sitting in a room with Dave Burke, who leads Android engineering - And Dave was quiet as we walked through all of the data and he said at the end: "One the one hand this is a pretty  big deal. On the other hand, this 

looks like an absolute no-brainer. Do  you think we can pull it off for IO?" And today we are making Kotlin an officially supported language in Android. We are also announcing our  plans to partner with JetBrains. Max Shafirov is here today. We only had maybe eight weeks to IO. I don't think most people realize that.

And so, we called-up Max Shafirov, who is the CEO of JetBrains and just a wonderful person. And keep in mind it's like March - IO is in May. And we said "Hey, we think your  language is pretty awesome. - We would like to figure out how to make it a first class language in Android. Love to see it be a top language in the world. Um. Do you think we could work together and announce that in like six to eight weeks?"

And Max was like: "Yeah, I  think we could figure that  together - let's get started,  let's see how far we get." Kotlin is perceived by some people as a language for Android only. It's not true now. And in the future, I really hope to see more and more people using it for full stack development. Including backend, web and mobile targets.

And also benefiting from sharing some parts of the codebase. Extracting these parts into common modules and supporting it for different targets. It kind of grew organically. It started with a Javascript backend - that was just a small project. The Kotlin-Javascript showed that it's possible to port Kotlin to a different platform. And then the decision to start Kotlin Native was made.

And that moment, that was the actual seed of multiplatform. That is what kick started the  whole design process of figuring  out how would you share the  code between multiple platforms. And creating all the infrastructure,  and the compiler, the tooling  in the language to actually support  this scenario of shared code. Doesn't matter if you build a mobile application, a website, or even a desktop application. So, we chose Kotlin to power our GraphQL servers - specifically because it had null safety built-in. That, basically, allowed us  to module our data classes  exactly the same as they look  like in the GraphQL schema.

It was a huge productivity gain for us - being able to just use it as it is. Over the years, we build a number of Java libraries and - Being able to just use Kotlin as is - without rewriting all that - that was a must. The backend and the frontend were switched from Javascript to Kotlin. On the backend it was very easy, because - Running on the JVM, running bytecode is - from a  performance standpoint -  really, really more advanced.

And on the frontend, Kotlin allowed us to do more complicated things in an easier way. To transform what you have in your mind to your computer without any intermediate layer. When I first started writing Kotlin, it was this feeling of "Wow. I can be productive." "Wow. I can build something  new, something exciting, 

and things work, kind of,  the way I think about them." And with Kotlin/JS it was the same thing. The only difference was, like, at this point I was able to kind of open a whole new world, right? Because the web, the browser - it was a really exciting scenario. We are in a unique moment in mobile development history. The platforms have matured.

And engineers mostly understand that below the platform specific APIs like UI - Android and OS are very much the same. The industry has come a long  way from web based approaches, and familiar programming languages for mobile developers, and inconvenient UIs for application users. We have another option. Kotlin-multiplatform mobile.

As Kotlin code compiles into multiplatform formats with Kotlin/JVM and Kotlin/Native, you can use a common module as a regular mobile library. And the user experience is just as good as with normal native development. Since KMM allows you to use platform APIs that  are necessary - for example  for implementing the UI.

Kotlin Multiplatform - the output is Kotlin and it's Objective-C. We're getting Swift friendly - very native. For us, guiding our clients to  a native multiplatform framework  that creates that seamless  interop to the shared logic - It was a no-brainer. I'm personally coming from .NET and I have used C# before. And Java wasn't an option for me at all.

But the transition to Kotlin was very smooth for me. "Space" is an all in one solution for software developers and for the entire company. So it curries the needs of  software developers, and  needs of collaboration, project management. So we tried to combine such  features as Git hosting,  documents, issues, charts and  calendars all into one product. "Space" is 100% Kotlin. So, everything server side,  clients, mobile applications,  our IntelliJ plugin - everything is Kotlin.

Sometimes client features become complicated - like in case of chats. It has lots of logic, and it is  critical for us to share code  to ensure that the same complex  code is only written once. Many professors   choose Kotlin for their programming courses - and not only for Android. But also to teach fundamental concepts. Like basics, like object oriented ideas or algorithms.

We receive lots of feedback that students love Kotlin. I really hope that, at one point, we  will see Kotlin present by default in  any curriculum for software engineering  programs in different universities. This is backed by JetBrains. JetBrains makes some of the best developer tooling. And it just makes sense that JetBrains would continue to build this and support it. Kotlin's future is in long term growth.

Not to be this language of the current moment, but to stay here for a long time. So when we plan what to do, we try to look at long term trends. On what's going to happen in ten, twenty, thirty years. It also relates to platform support. The way we structure our  infrastructure for Kotlin compiler - we are trying to make it less dependent on a specific platform. So that we can adopt new platforms in the future easier.

Because we really cannot predict what platform will be popular in ten, twenty or thirty years. But we want Kotlin to stay  and be a relevant language  that is used by the industry in the future. When I lay in bed in the morning and I kind of scroll through my feed - and I see what people do with the technology - it gives me this warm fuzzy feeling of like: "Yeah, we are doing something exciting here."

2021-08-10 11:24

Show Video

Other news