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