[pjmlp]

Actually type safe, with support for various kinds of automatic memory management.

Pascal dialects, while much safer than C, suffer from use-after-free and possible memory leaks, also you don't need to mark unsafe code as such.

This includes any modern Pascal variant.

[The_rationalist]

Why use nim over Kotlin with AOT?

[beagle3]

I'm not familiar enough with Kotlin to give a real answer, but from what I do know the following might be relevant:

* Backends: Nim compiles to JS both directly, and indirectly (emscripten) with various trade-offs (e.g. 64 bit ints require emscripten). It also compiles to C, C++ and Objective C giving you the simplest most efficient FFI to those languages one can hope for (including e.g. exception handling) while at the same time addressing the largest set of platforms (got a C compiler? you can use Nim). And you also have (almost but not yet quite production quality) native code compiler NLVM. What's the platform range of Kotlin's AOT?

* Metaprogramming: Nim's metaprogramming ability is second only to Lisp[0], I think, and only because Lisp has reader-macros (whereas you can't ignore Nim's syntax with macros, as flexible as it is). For example, Nim's async support (comparable to Python and C#) is a user-level library. So is, for example, pattern matching. Can Kotlin do that?

* Size: Nim compilation through C produces standalone and (relatively) tiny executables; it matters for embedded platforms. How does Kotlin fair in this respect?

[0] Lisp, scheme and other Lisp derived languages, of course.

[draegtun]

>> Metaprogramming: Nim's metaprogramming ability is second only to Lisp[0], ...

There are some other languages that have metaprogramming abilities equal to Lisp. For eg. Rebol, Red & Forth.

I think some people would also consider Prolog and Smalltalk to be in the same ballpark.

And there are languages that would also claim to be second only to Lisp, for eg. Julia, Elixir, Raku/Perl6 and probably some others to!

[The_rationalist]

Nim compiles to JS both directly, and indirectly (emscripten) with various trade-offs (e.g. 64 bit ints require emscripten) Kotlin can also compile to js directly and can autogenerate typescript definitions for the generated code.

It also compiles to C, C++ and Objective C giving you the simplest most efficient FFI to those languages one can hope for (including e.g. exception handling) while at the same time addressing the largest set of platforms (got a C compiler? you can use Nim). Wow, nim has implemented that much transpilers? This is kinda impressive but I would rather want a language that compile to Binary instead of compiling to another language, AND that offer nice FFI interop Kotlin has state of the art language interop through graalvm but here it does not qualify as native. For native interop it can be done but is subpar. But openjdk is working on a new API luckily.

Metaprogramming Interesting topic for sure! I've never learnt a LISP. I did use macros when I was doing C/C++ and honestly I don't get their advantages vs @Decorators() (pre compile time codegen) and they have a reputation of breaking IDEs Kotlin like Java can generate code/classes at runtime and has full support for reflection. Tangeant: Kotlin can mark any function as in/postfix which allows to easily create DSLs. Due to this Kotlin community has created a lot of elegant, declarative DSLs such as for testing.

Nim's async support (comparable to Python and C#) is a user-level library. Kotlinx.coroutines is the official library the language simply has to expose the keyword suspend.

So is, for example, pattern matching. Can Kotlin do that? Kotlin has some pattern matching features in its when keyword,but no it cannot currently destructure in when. But the subject is active and it should come in a following release, especially since Java is getting pattern matching. https://github.com/Kotlin/KEEP/pull/213

But if your point was that macros allows to modify the abstract syntax tree, Kotlin compiler plugin API offer much more power (you can modify anything anytime (the AST, the IR, the bytecode) It is arguably far harder to use than powerful macro but it does not prevent experimented guys from scalaifying Kotlin through https://github.com/arrow-kt/arrow-meta/issues They are bringing for example union types as an unofficial extension to the language. They could bring pattern matching earlier in theory.

Size: Nim compilation through C produces standalone and (relatively) tiny executables; it matters for embedded platforms. How does Kotlin fair in this respect?* I'm afraid kotlin is not made for such a use case but today even embedded platforms should have a few dozens of free MBs

[vips7L]

Kotlins stdlib is seriously lacking, at least the last time I looked at it, you couldn't even read a file without java.io.

[The_rationalist]

You can and you should use Java libs where appropriate. It's always nice to have pure idiomatic Kotlin but calling Java from Kotlin is already idiomatic.

As for multi platform io they are working on it https://github.com/Kotlin/kotlinx-io

[vips7L]

But the discussion was about Kotlin AOT. Not kotlin JVM.

[The_rationalist]

Right but using graal native instead of kotlin native you can have kotlin calling Java code and compiling to a binary

[ptx]

I'm hopeful that Kotlin/Native will improve in these areas (excepting the last one) but:

* Faster compilation.

* Tooling is less memory-hungry.

* C++ interop.

* Macros.

[vips7L]

Tooling as in intellij/gradle? I doubt they'll ever use less memory.

[The_rationalist]

Actually intellij since 2020.1 release is kinda fast :0

[The_rationalist]

Why macros vs decorators?

[ptx]

I think you basically covered it in your other comment. Macros are much quicker and easier to write than compiler plugins or annotation processors, but they are difficult for the IDE to understand. So it's a trade-off where Nim and Kotlin both make reasonable, but quite different, choices.