Some time ago I published a post titled Kotlin vs Java the Whole Story. It was, by a large margin, the most read and discussed article that I wrote to date.

I was quite surprised by the extent of community feedback because the initial intent behind that post was very humble. I just wanted to prepare an objective ground for an upcoming strategic analysis of Google’s adoption of Kotlin programming language for Android development.

After taking some time to process the community feedback and discuss it with my friends and colleagues, I realized that it will be useful to discuss why JetBrains invented Kotlin and markets it to developers today.

Kotlin productivity myth:

One statement that I often hear and read is that JetBrains invented Kotlin because they weren’t satisfied with Java and wanted to increase their own productivity. This statement takes on different forms, but the underlying assumption is always the same: JetBrains invented Kotlin because Java was “bad” in some aspect.

The immediate conclusion from such an assumption is that Kotlin is much more productive than Java, because, otherwise, JetBrains wouldn’t invest in its development and wouldn’t use it in their own projects.

At this point, it is important that we make a distinction between JetBrains as a company, and individual developers who work on Kotlin.

We, developers, have bad subjective judgement in general, and usually don’t fully aware of the costs of the projects that we are working on. Therefore, individual developers who bootstrapped Kotlin might have very well believed that it is justified to spend several calendar years working on a completely new language for a questionable productivity and performance gains down the road.

JetBrains as a company, on the other hand, is a very successful business. It is improbable that such a serious company hadn’t performed a basic return-on-investment (ROI) analysis before they committed to Kotlin.

When estimated the investment, JetBrains analysts should’ve taken into account at least the following costs:

Developers salaries Salaries of additional non-technical staff The cost of effort multiplication on internal projects that tested Kotlin over the years (discussed in Kotlin vs Java the Whole Story article, but much higher because back then Kotlin was even less mature than today) Marketing expenses Opportunity cost of all the staff involved in the project

Even the most humble investment estimations for such a project would yield numbers in millions of dollars. Maybe even tens of millions.

What were the estimated returns?

From internal productivity point of view, there were probably none.

Even today, when Kotlin is post 1.0, it is not clear whether it is more productive than Java, and if it is, to what extent. However, in 2010-2011, when go-no-go decision about Kotlin should’ve been made, there were absolutely no indications that would allow to perform a quantitative estimation of the impact of Kotlin on developers productivity.

Is it possible that JetBrains committed to an extremely long, multi-million project just because a group of developers claimed that they are able to develop a language that will be “better” than Java and will make them more “productive”?

Very, very improbable.

Why Kotlin:

If we can agree that JetBrains is a serious and successful business, then there should be something about Kotlin that convinced JetBrains analysts and management, back in 2010-2011, that it was a worthwhile investment.

In other words, the answer to the question “why Kotlin” should be rooted in JetBrains business strategy.

I should say right away that analyzing business strategies is not exactly my area of expertise. Fortunately, more than 15 years ago, Joel Spolsky (founder and CEO of StackOverflow) already demonstrated a framework for such an analysis in his Strategy Letter V.

All we need to do is reframe Joel’s ideas in context of JetBrains and Kotlin.

What’s JetBrains business model? They sell software development tools. In particular, their most recognized line of products are IDEs.

What’s the natural complement of IDEs? Right, programming languages. Therefore, it is in JetBrains best interests to reduce programming languages to commodity status.

However, programming languages are very hard to turn into commodity. It is hard because even though most programming languages are free to use, the cost of switching between different programming languages is usually very high. It is extremely hard to convince businesses to adopt new programming languages. Therefore, different programming languages are not perfect substitutes.

From IDE vendor’s point of view, all programming languages are different because they require a support for different set of tools and techniques and might evolve in completely different directions. Therefore, as an IDE vendor, each time a new programming language appears and gains traction, JetBrains need to invest a lot of effort in order to support it in their IDEs.

So, if programmers and businesses entrench themselves in their favorite languages, and support for each new language is a huge PITA for IDE vendor, what would be the ideal situation for JetBrains?

It doesn’t take a genius to figure out that, given the above constraints, the ideal outcome for JetBrains would be to have programmers converge on a single favorite language which is relatively easy to support. And no language is easier to support than the one you develop in-house.

Therefore, one of the motivations behind Kotlin is to migrate developers to a language that is relatively easy to support from JetBrains perspective.

But wait, there is more.

Programming languages are complements of IDEs, but IDEs are also complements of programming languages. We already discussed that programming languages are very hard to commoditize, but what about IDEs?

Different IDEs have different features and different look and feel, and developers usually have strong preferences for specific IDEs. Therefore, different IDEs are not perfect substitutes either.

However, compared to programming languages, IDEs are much easier to switch. For example, some developers who use paid version of IntelliJ at work wouldn’t buy a license for personal projects. If these developers aren’t satisfied with the free version, they can readily use Eclipse, Atom, Notepad++, Emacs, etc.

What this means for JetBrains is that they are always at risk of losing customers because both individuals and entire businesses can decide to use alternative IDEs at any instant.

The risk of losing a market share is especially profound for JetBrains when new programming languages (or new frameworks built using the existing languages) appear and become popular. Different IDE vendors rush to support the new languages, and the IDE market shares for these new languages can end up being very different than for the old languages.

So, if JetBrains is experiencing a fierce competition in IDEs space, and each new language or framework introduces a risk of losing a market share, what would be the ideal situation for JetBrains?

It would be good for JetBrains if existing customers would not be tempted to go for alternative IDEs when new languages and frameworks appear. It wold be simply outstanding if appearance of new languages and frameworks would cause new potential customers to be more likely to choose JetBrains products over competitors ones.

And now answer a million dollar question (probably much more than a million though): if a company X decides to use Kotlin for development, which IDE vendor is likely to be chosen by X?

Therefore, additional motivation behind Kotlin is to increase the market share of JetBrains IDEs, and prevent customers leakage to competitors when new frameworks appear.

The last advantage that JetBrains can get out of widespread Kotlin adoption is easier marketing of their non-IDE tools.

While Kotlin, as a language, shouldn’t affect the choice of e.g. continuous integration server (TeamCity) or issue tracker (YouTrack), the sole fact that developers will use Kotlin and IntelliJ, will probably make it easier to convince them to use additional JetBrains products.

In the long run, by owning a language and providing an entire stack of development tools, JetBrains might “copy” Microsoft’s .NET development ecosystem. If this is indeed their end goal, then, in my opinion, they have a very high chance to succeed in this endeavor.

I don’t buy your proofless accusations:

Based on the feedback from a previous post and many discussion of this topic that I had with friends and colleagues, I know that many readers already feel uncomfortable at this point, maybe even angry. I would like to further explain myself in order to avoid any possible misunderstandings.

Let’s break it into two parts: proofless and accusation. I’ll start with accusation because that’s the more important aspect to address in my opinion.

If you felt like I’m accusing anyone while reading the post, please stop reading for a moment and try to think why you got this feeling. Was it because it looks like I claim that JetBrains invented and promotes Kotlin in order to move their business forward and eventually make money?

First of all, good job understanding the post because I indeed claim that Kotlin is part of JetBrains overall business strategy, and not a tool they developed in order to increase internal produtivity. However, I’m not accusing anyone of anything.

See, I acknowledge the fact that the main purpose of businesses is to make money. Furthermore, as a software professional, I enjoy salaries which are much higher than average. These high salaries are possible only as long as businesses in our industry make terrific amounts of money. Therefore, not only I understand that businesses make money, I also encourage businesses in software industry to make as much money as they can under constraints of laws and ethics.

Furthermore, as an independent software consultant and developer I don’t have an employer which would pay for the tools I use. Therefore, I pay for them myself. IntelliJ Ultimate is an essential tool in my toolbox and I happily pay its licensing fees today, and will continue to pay in the future.

So, no accusations here. Just some dry facts and deductions.

Now let’s discuss the “proofless” part.

First of all, I don’t think that anything in this post needs proof because no accusations were made. In addition, the facts that I listed and the motivations that were deduced from these facts are as straightforward as it can get.

However, for many developers who believed that JetBrains invented Kotlin in order to make their lives easier, the idea that the driving force behind Kotlin is business interests might be hard to accept. Especially when it comes from a random guy on the internet.

Luckily for us, Dmitry Jemerov shared with us why JetBrains needs Kotlin way back in 2011. Among other things, Dmitry stated:

The next thing is also fairly straightforward: we expect Kotlin to drive the sales of IntelliJ IDEA Dmitry Jemerov

In my opinion, however simple this fact to deduce, stating it on a company blog is a startling example of openness of a business towards its potential customers.

So, all in all, if you want to know my subjective opinion about JetBrains endeavor with Kotlin – I admire it.

JetBrains committed to a very complex, long term and expensive project, and invested a lot of effort into Kotlin. Then they tested the language on internal projects for years, and managed to slowly build a strong community around it. From business strategy and project management point of view, I think JetBrains did an outstanding job.

Now, be careful not to interpret the above statement as me being Kotlin fan. Even though I respect and admire what JetBrains did with Kotlin, as a developer I’m far from being convinced that actively migrating to Kotlin is a good idea.

Therefore, while it is far from clear at this point whether Kotlin will become a serious player in programming languages league, I do hope that Kotlin will turn out to be financially beneficial for JetBrains.

Conclusion:

Let’s summarize what we discussed.

It is very improbable that a project of the size, the cost and the complexity of Kotlin was approved by JetBrains because their developers believed that they can make a language which is “better” than Java.

In my opinion, the main motivations behind invention and marketing of Kotlin programming language are as follows (in descending order of importance):

Increase the market share of JetBrains IDEs, and prevent customers leakage to competitors when new frameworks appear Reduce the required marketing effort for additional non-IDE tools Migrate developers to an in-house language that is easier to support

I would like to state once again that I’m not accusing anyone of anything in this post. On the contrary – as a professional, I respect the challenges and the risks that JetBrains accepted with Kotlin project. I’m also happily paying for great tools by JetBrains and other commercial companies myself, and encourage these companies to make money.

What I do want to achieve with this post is to make software developers realize that claims like “Kotlin is good because JetBrains invented it in order to increase their own productivity” are a bit naive.

Maybe Kotlin is “better” than Java, and maybe it is not. It is quite possible that we will never know which of them is actually “better”. What is certain, however, is that the fact that JetBrains uses Kotlin on internal projects has nothing to do with Kotlin’s “goodness”. It is, most probably, just part of JetBrains general business strategy.

So, there is a business strategy behind Kotlin’s invention and marketing, and we should keep that in mind when evaluating a migration to Kotlin as an option.

In the next post in this series we will (hopefully) discuss the topic that I find the most interesting in respect to Kotlin: why Google adopted Kotlin as a first class language for Android development.

Please leave your comments and questions below, and consider subscribing to our newsletter if you liked this post.