Kotlin/Native v0.2 is out

16 Responses to Kotlin/Native v0.2 is out

1. Pavel says:

   May 12, 2017 at 6:59 pm

   Congrats!
   Could you provide a tutorial to build simple kotlin-native app with IntelliJ Idea?

2. Pingback: Kotlin/Native v0.2 is out (Official announcement from Jetbrains) | Ace Infoway

3. Nikolay Igotti says:

   May 12, 2017 at 7:37 pm

   IDE support for Kotlin/Native is in progress, you may try to use Gradle support in IDEA along with Kotlin/Native Gradle plugin (see https://github.com/JetBrains/kotlin-native/blob/master/GRADLE_PLUGIN.md)

4. Pingback: Kotlin/Native v0.2 发布，将 Kotlin 编译成机器码 | News Pod

5. Clóvis Valadares says:

   May 14, 2017 at 4:17 am

   When a windows version?
   • Nikolay Igotti says:

     May 14, 2017 at 11:09 am

     Windows version is being worked on, but we cannot provide ETA yet.
6. Al says:

   May 14, 2017 at 5:30 am

   Does the existence of Kotlin Native mean there will be proper tail call elimination even without the JVM supporting it? I’ve always felt that lacking this is annoying considering it’s entirely technically possible even on the JVM if resources were invested to make it a reality (it’s just not important to Oracle’s customers for Java). Even Microsoft’s F# supports these optimizations despite running on the CLR.
   • Nikolay Igotti says:

     May 14, 2017 at 11:12 am

     For tail recursion case there’s ‘tailrec’ keyword, which is being supported in Native as well. For other cases, tail call elimination could be done by LLVM backend for some cases.
7. Marcel Bradea says:

   May 19, 2017 at 12:57 am

   Guys where are Kotlin feature requests tracked? Can’t find anywhere to post this.

   Anyways our feedback from maintaining a full dual-platform Swift/Kotlin codebase (same engineer implements features natively in both platforms) is that there are still several features that Kotlin as a language still lacks in order to be on par with Swift and thus iOS.

   One in particular that comes up constantly is the lack of lateinit in delegated properties.
   ie: There is essentially no way to convert the following Swift code in Kotlin:

   var link:Link! { didSet { // hydrate hydrate() } }

   1 2 3 4 5 6 7

   var link:Link! {     didSet {         // hydrate         hydrate()     } }

   The closest Kotlin equivalent forces the variable to be optional, which loses the semantic and is against the whole Kotlin/Swift optionals movement (ie: forces you to use a nullable field for something that is semantically non-null):

   // Closest current workaround: use a backing field with accessor wrapper private var _link:Link? by Delegates.observable<Link?>( null ){ property, oldValue, newValue -> // hydrate hydrate() } var link:Link get() = _link!! set( newValue ){ _link = newValue }

   1 2 3 4 5 6 7 8 9 10 11

   // Closest current workaround: use a backing field with accessor wrapper private var _link:Link? by Delegates.observable<Link?>( null ){ property, oldValue, newValue ->     // hydrate     hydrate() } var link:Link     get() = _link!!     set( newValue ){         _link = newValue     }

   Of course the real solution is to allow ‘lateinit’ to be used in conjunction with delegated properties:

   // PROPOSED lateinit private var link:Link by Delegates.observable<Link?>(/*NOTE: no default value*/){ property, oldValue, newValue -> // hydrate hydrate() }

   1 2 3 4 5 6

   // PROPOSED lateinit private var link:Link by Delegates.observable<Link?>(/*NOTE: no default value*/){ property, oldValue, newValue ->     // hydrate     hydrate() }
   • Nikolay Igotti says:

     May 19, 2017 at 12:45 pm

     Please use Kotlin issue tracker here: https://youtrack.jetbrains.com/issues/KT
   • Alexander Udalov says:

     May 19, 2017 at 2:21 pm

     Wouldn’t declaring a custom delegate help here?

     class PropertyWithOnSetAction<T>(private val onSet: () -> Unit) : ReadWriteProperty<Any?, T> { private var value: T? = null override fun getValue(thisRef: Any?, property: KProperty<*>): T = value ?: error("Property ${property.name} is not initialized yet") override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) { this.value = value onSet() } } var link: Link by PropertyWithOnSetAction<Link> { hydrate() }

     1 2 3 4 5 6 7 8 9 10 11 12 13

     class PropertyWithOnSetAction<T>(private val onSet: () -> Unit) : ReadWriteProperty<Any?, T> {     private var value: T? = null       override fun getValue(thisRef: Any?, property: KProperty<*>): T =             value ?: error("Property ${property.name} is not initialized yet")       override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {         this.value = value         onSet()     } }   var link: Link by PropertyWithOnSetAction<Link> { hydrate() }
     • Marcel Bradea says:

       May 19, 2017 at 9:06 pm

       Thanks for that example Alexander.

       I bring this up in particular because if you are to support iOS native, this is an extremely common scenario in literally every Swift codebase I have seen – and has no current out-of-box Kotlin equivalent.

       I don’t think requiring teams to make their own custom delegated properties is the way. This needs to be standardized and provided either at the language level or in the base Kotlin libraries (ie: delegates.observable).

       I’ve filed an issue for it here: https://youtrack.jetbrains.com/issue/KT-17979

       Congrats again to the huge Android/Google news guys.
8. Roman says:

   May 20, 2017 at 9:54 am

   Have you done any benchmarking of Kotlin Native vs Kotlin JVM ? Which one is expected to have better performance?
   • Nikolay Igotti says:

     May 20, 2017 at 4:12 pm

     Performance is multidimensional notion, so it really depends on what is measured. Startup performance, memory management pauses and pure computations are likely better with Kotlin/Native, while massive object manipulations shall be better with Kotlin/JVM. Also note that current Kotlin/Native runtime wasn’t optimized, unlike modern JVMs, where thousands engineer/years spent on optimizations.
     • Roman says:

       May 20, 2017 at 7:22 pm

       I see, so it depends on particular application. Is it possible to use two runtimes simulatneousy and how interop will look like? Can I for example call K/N funciton from K/JVM and pass reference to JVM managed object as a parameter?
       • Nikolay Igotti says:

         May 20, 2017 at 11:23 pm

         Kotlin/JVM -> Kotlin/Native interop is not currently supported, beyond generic Kotlin/JVM -> C interop. Arbitrary object interoperability is unlikely to be supported soon.

Comments are closed.