The first release of Kotlin 1.0 has been released.

Yesterday the first release (1.0) of the Kotlin programming language from the company JetBrains was released .
As the company writes in its press release yesterday , “it was a long way but we finally released the first release and at the same time present a new logo (icon) of the language”

We’ve finally reached the first big 1.0

It focuses on the fact that it is a pragmatic PL for JVM and Android with an emphasis on compatibility, security, expressiveness and good tools:

It is a pragmatic programming language and Android that combines the interoperability, safety, clarity and tooling support.

Being a general-purpose language, Kotlin works everywhere where Java works: server-side applications, mobile applications (Android), desktop applications. It works with all major tools and services such as
IntelliJ IDEA, Android Studio and Eclipse
Maven, Gradle and Ant
Spring Boot (Kotlin support released today!)
GitHub, Slack and even Minecraft :)

')
The concept of pragmatism is emphasized in this case - the creators did not aim to invent a completely new PL and concepts, but built for example a type system that prevents bugs or created abstractions - which promote code reuse and generally focused on things capable of making PL a very good and convenient tool. :

Understanding one's core values ​​for any long-running project. It would be pragmatism. Kotlin is not so much about invention or research. This was never the point of the project. Of course, we’ve been able to build a system of But it’s a good tool.

And also the most critical - compatibility with existing code and infrastructure:

In particular, this approach is interoperability with the existing code and infrastructure is crucial.

That it was necessary to be retrained less, to rewrite, ie the more you can reuse - the better:

But elegance, though it is not the goal, it is not useful. You can re-use, you can re-invent, re-invent, re-invent

For the same reasons, the own project builder was not created, and it was also decided to use the same collection interfaces as in the JDK, the latter including for simplicity, to avoid the problems of converting data "back and forth":

- So, why doesn't it have a package manager?
- Because there’s already a number of plugins, it’s crucial for many projects.
If you’re looking for a collection of scratch?
It is a pain.

The creators emphasize that the language is fully ready for industrial use and tested on many real-scale projects:

Is it mature enough and ready for production?

Yes. And it has been for quite some time. At JetBrains, we have not only been a scale for the last two years. In addition to JetBrains, there are quite a few companies that have been using for some time now.

It is explained that such a long way to release (more than 5 years since its introduction in 2010) was due to a thorough check of architectural solutions in practice, since The compiler should be backward compatible with all future versions of Kotlin:

In fact, we’ve paid a few minutes to reach 1.0. It should be noted that the compiler must not be able to break existing code. We need to stick with them.

What is behind Kotlin's scene? An open-source project and hundreds of contributors, JetBrains is now the main sponsor of Kotlin, which has invested huge resources in it and will continue to do so in the long term. Already, about 10 large products of the company use Kotlin.

At the moment, JetBrains is the most important thing to do. We wrote it out. Close to 10 JetBrains products, which include IntelliJ IDEA, JetBrains Rider, JetBrains Account & E-Shop, YouTrack and Kotlin. So it's here to stay!

The company plans to organize a centralized discussion of proposals for the further development of the language and to make this process even more transparent.

We are visible and organized. It is not a problem.

The architecture of the language and the development of the project is carried out by a team within the company of more than 20 people in full mode.

By the team employed at the JetBrains. We currently have over 20 people working full time on Kotlin, which is also another testament to JetBrains' commitment to Kotlin.

The first release focuses on the long-term backward compatibility of the language and its standard type library:

As of 1.0, we are committed to long-term backward compatibility (kotlin-stdlib)
you can’t understand newer binaries, like javac 1.6;
-older binaries will keep working with newer binaries at runtime (newer code may require newer dependencies, though).

The nearest plans are constant improvements in the language toolboxes, support for JavaScript (compiling both in JVM and JS where possible) and optimizing the generation of Java bytecode using new features.

As for the plans, our distance goals are (apart from the fixes):

Kotlin toolchain (this includes, for example, incremental compilation in Gradle, that is in the works now);
JavaScript support (including cross-compilation into both JVM and JS where possible);
Supporting Java 8 byte code with optimized lambdas, etc (for Android users need it).
Fixes will be released as incremental updates, ie 1.0.X. It’s a funky way to get it, and it will be released as 1.1.

Docks, manuals - available on the official resource of the project - kotlinlang.org
Feedback via forum or chat chat

Have a nice Kotlin! Now :)

ps everything seems cool and expected, thank you all, the only caveat only casts doubts - the guarantee of eternal backward compatibility, i.e. same as java itself. Is it necessary? The consequences are known by the example of detrimental generics, outdated design collections and not always convenient implementation of lambdas and so on. many can themselves add from sore. Is it so critical if once in 10-15 years this backward compatibility is not respected to change the language for the better? We already have Java with perpetual backward compatibility, do we need it now in Kotlin? I propose to vote: