I’m wondering if anyone came up with a way to: • measure the time of what happens between starting a Kotlin script to the start of execution (how much time it takes to compile and run the JVM) • optimize the above, especially the JVM startup

Not really an answer to the original question but for scripting, I don't mind the performance too much in general. Adding a few seconds start time is OK for me. If I need more speed, I convert to a plain project and use precompiled artifacts (.jar, K/N, Graal, ...)

for me generally as well, but I’m trying to foresee certain things that may be pointed out by folks favoring e.g. bash or Python scripts. This is one of the areas where Kotlin is worse

Yea, I have no argument for that. Wait for K2 ? 😅

that’s why I’m also interested in measuring JVM startup time - K2 won’t influence it, right?

1. Wrap kotlin-compiler-embeddable and log time around executing empty script file (or just clone and use petuska.dev/ktx for this experiment) 2. Compilation is cached on first run so subsequent runs skip that step

I'd expect compilation to be a lot slower than JVM start time. JVM starts in ~30ms on my machine

For our kotlin scripting app, compilation takes a few seconds and we cache the jars so after that runnin the scripts only has about 30-50msec of jvm startup. AppCDS helps by about 30%

AppCDS?

We have an internal kotlin scripting engine called hshell that provides a lot of useful features, we use it instead of bash and it's much nicer. There are functions like

cd

,

ls

,

cp

,

mv

,

find

etc. Can echo markdown to the terminal and it'll be formatted, progress bars are built in, lots of other useful stuff. The only downsides are really the size of the install (lots of features = lots of jars) and the fact that the kotlin compiler is kinda slow. At some point I want to try compiling kotlinc with native image. But even with a few seconds delay when you change a script it's still much more pleasant.

try compiling kotlinc with native image

You mean turn the Kotlin compiler into a native binary 👀 ?

and consider open-sourcing it 😉

Yeah, turning it into a native binary. It might not be faster for regular kotlin dev because kotlinc uses a daemon that warms up, and peak perf on hotspot is better than native images (CE edition), but for the scripting use case it'd be better. I've thought about open sourcing hshell, but these days I need to make money and also I'm getting older. Maintaining open source projects in my spare time gets less appealing. I've done it in the past and it can turn into an open ended commitment that lasts years. So I've also thought about just selling it for some reasonable price, $50 a user or something.

OSS funding is hard...

Yeah. If JetBrains or someone else wanted to buy it and open source it, great. I'd definitely consider that. There's also another issue - hshell is largely Kotlin Scripting fused with the internal APIs I developed for Hydraulic Conveyor. It's a sort of build system for win/mac/linux packages so there's lots of file system manipulation, showing of progress, rendering nicely to the console etc. I wrote all those features as independent modules so the logic would look like shell scripting and it worked out well, but, it does mean releasing it as a product effectively freezes parts of the internal APIs which would make the rest of the product development harder.