😄

Wondering what would be different between native and JVM. Are they considered backends?

Native compiles to native code, JVM compiles to bytecode.

Same compiler though?

(other than llvm I guess)

Depends on what you consider to be a compiler.

Compiler has so many parts…

So many moving parts…

I guess, the end user facing part.. But I guess even that doesn't matter

Since that's just 0.000001% of it

There are so many question yet to answer

Yeah, I bet. I guess you guys would have to write your own stdlib, instead of tapping into Java's stdlib

That would be interesting :)

I think the biggest thing I've hated about native code (other than c++ having oh so many pitfalls) is dependency support. In Java land it's so simple to add another library, there's just no fear of doing it unless you're meeting strict sizes

Native is always "oh no if I add this library that actually uses a diff build system now I have to hook that into this" and after a few of them you realize building for multiple targets just got way more tricky

But that was just my experiences anyways.

I believe swift is trying to solve that but hasn't gotten anywhere. Rust might be further in that dept

Why not just use Gradle? It’s known to support at least Android NDK toolset, so should be fine in running C++ compilers in general?

My experience was before gradle even did c++, or perhaps when it was experimental, I think

good thing with gradle is gradle-script-kotlin. You see where it’s going 😉

good thing with anything is anything-kotlin 😉

I wonder how realistic native code would be. Because it seems like compilers take many years before they achieve optimization parity. Like how long clang has taken (and I think it's still behind)

Or was most of that work benefiting from llvm changes and thus everything benefits to a large degree

Currently, there're basically 4 major mature native compiler back-ends: GCC, LLVM (Clang), Intel's proprietary, and MicroSoft's proprietary. Kotlin Native relies on LLVM for low-level optimizations and native code generation. Personally, I believe in LLVM in long-term.

And then, there's iOS as one of the primary targets for Kotlin Native, and that almost means LLVM.

Then, I've heard of at least 1 LLVM-to-ICC project...

So, yep, I'd definitely bet on LLVM.

What language do you use to develop frontend for LLVM?

Kotlin Native itself is written in Kotlin. NB: don't want to take credit for other people's work. My primary contribution to Kotlin Native so far is high-level IR (that we are going to use in other BEs, including JVM BE "2.0" and JS BE "2.0")

That's cool. Didn't expect such answer.