Kotlin Native has some server-side samples, could that be extended to cover Serverless? Is Serverless development going to be officially supported in Kotlin Native?

But what is serverless development? I mean each “serverless” service has own API and even own supported platforms (jvm/js/native)

There are some frameworks like Serverless (https://serverless.com/framework/) which attempt to provide a common API that works across all FAAS (Function As A Service) platforms. Serverless these days has become the defacto framework for FAAS platforms, and has official Kotlin support (for Kotlin JVM and Kotlin JS, no Kotlin Native support yet ⏲️).

But it requires support of Serverless Framework, probably it should be done by community, don’t think that support of one particular framework by K/N team is a right solution on current stage of K/N

Agree with the community providing support for Serverless with Kotlin Native. Do think that the Kotlin Native team can do some basic things (likely small bits and pieces) to ensure that Kotlin Native works well on FAAS platforms (aka platform neutral).

Do you see any problems with it? As I understand you can deploy K/N program to any faas platform with support of binaries

Are there some FAAS platforms that allow binary deployment? Some FAAS platforms allow for Docker deployment.

Because if you have http server it’s trivial to implement any faas with support of binaries

There is a case of Kotlin Native working in Open Whisk: https://jaxenter.com/kotlin-native-serverless-tutorial-fibonacci-fun-136615.html

yes, just docker image

Just to clarify where the Kotlin Native team fits into this. There are Kotlin Native performance optimisation's that will need to be done to ensure the Kotlin Native runtime is performant in Serverless use cases, and the Kotlin Native team is in the best position to do this.

How “Serverless use case” is different from other use cases? Startup time? it’s already pretty fast, much faster than jvm Any performance optimisations is good for any use case

in a sense, even KotlinConf Spinner example https://github.com/JetBrains/kotlinconf-spinner/blob/master/kotlin-native/samples/fullstack/httpserver/src/main/kotlin/server/HttpServer.kt contains “serverless” server (i.e. lightweight standalone server), which is running for a year already, without much problems

Funny thing that such self contained server is not what people expect from “serverless”, they want integration with some third party “FaaS” service For example on openwhisk you even don’t need http service inside, they pass request to main function arguments as Gson JsonObject 🤔

yep, term is somewhat vague indeed, but at least if we’re talking about producing small standalone binaries written in relatively high-level language - K/N is pretty good here

This is runner for Kotlin: https://github.com/ibm-functions/runtime-kotlin/blob/master/kotlin/proxy/src/main/kotlin/openwhisk/kotlin/action/Proxy.kt

that’s Kotlin/JVM one, I guess

this is what actually runs your functions, no magic there

running it as a standalone process would provide better isolation and resource control, I’d say

They run this service on each request, as I know

One way to understand “serverless” that helps me is that “server” here is not a dedicated hardware, and being serverless doesn’t mean running in a cloud. “Server” here is a dedicated software (web server, framework, etc) that has a specific lifecycle (binds to a port, listens to connections, processes http requests). Hence FaaS is serverless, but docker with a http server is not.

I would like to experiment about Kotlin/Native support for Serverless, and I am thinking about the deployment options because even if most platform runs under Linux x86-64 that could be not always the case. Could we imagine using Klib as a deployement unit to deploy LLVM bytecode on a FaaS that could be compiled as an native executable on the Faas platform ?

It’s actually not clear for me why wasm instead of platform compatible binary?

You don't know the internals of the system you are deployed on, this is sandboxed runtime so great for security, it is a good trade-off between performance, flexibility and security

Docker example shows that generally Linux binaries are good enough executable unit format representation, so I’d suggest to use raw native code instead of yet another VM

In other words Kotlin Native would be a good way to go depending on what Serverless software is being developed.

There are serverless environments for Swift. I think IBM's OpenWhisk offers it. Perhaps Kotlin-native could run in a Swift environment?

Swift runner for OpenWhisk compiles Swift files itself. There is no magic. The only thing what they do is compile your swfit source code on their server I don’t see any problems to do same for K/N, they even use gradle as a build tool for swift, I just think that this approach is strange, but if people like, maybe who is really intereseted, could write openwhist runtime for K/N, it shouldn’t be hard. But Swift and possible K/N has a problem: first time when you run your action your file with function will be compiled before execution, not so bad, it will be cached. But still this can be avoided using docker image

Make sense yeah