if you are willing to pay money, you can get them

am only really interested in those jvm features that are available to everyone

writing a library?

well, i work on open source, so it wouldn't be all that good if it required a proprietary JVM to work properly...

right

i am unaware of any open source JVM that has resource limiting, indeed. And yeah, a nice way to embed kotlinc would be great. Perhaps a javax.scripting contribution would be accepted by JB as a pull request

you can get most of the way there with a custom security manager and/or

Policy

, but the main thing that's lacking is a way to prevent individual threads from consuming too much heap or CPU time

the lua VM can limit based on the number of instructions executed and so on

yeah, that's what the oracle JVM adds.

think i saw the JSR

yeah, jsr 284

hmm. oracle's documentation is so bad i'm not even sure if that's the one i mean. it was added in 8u40

ah ha

it's ridiculous. it's almost like they don't enjoy being paid money.

as it's in the JDK namespace I guess it's not an implementation of the JSR

heh

558 votes and kotlin in second place behind scala https://twitter.com/joewalnes/status/701790012476682240

nice. very even results, actually

do not believe twitter

Do not believe anything crowd, I would say. But since we are not selling anything, what metric to choose? 😉

it would be nice if I could mark a class as @NotThreadSafe and then have the compiler do flow typing on member variables.

Is there any Kotlin to Java converter?

no

How do I change channels?

Given the following class hierarchy:

class PropertySpec()
class GeneratorAdapter()

class PropertyAdapter() {
  fun GeneratorAdapter.generateRead(property: PropertySpec) = println("read")
  fun GeneratorAdapter.generateWrite(property: PropertySpec) = println("write")
}

Is it possibe to invoke

generateRead

and

generateWrite

methods outside of

PropertyAdapter

context? The following code doesn't compile in Kotlin:

val generator = GeneratorAdapter()
val property = PropertyAdapter()

property.generateRead(generator, PropertySpec())
property.generateWrite(generator, PropertySpec())

But the same code works fine in Java:

final GeneratorAdapter generator = new GeneratorAdapter();
final PropertyAdapter property = new PropertyAdapter();

property.generateRead(generator, new PropertySpec());
property.generateWrite(generator, new PropertySpec());

The only workaround I've found so far is to use

property.apply {}

syntax:

val generator = GeneratorAdapter()
val property = PropertyAdapter()

property.apply { generator.generateRead(PropertySpec()) }
property.apply { generator.generateWrite(PropertySpec()) }

Questions: 1. Is is possible to invoke

generateRead

and

generateWrite

without wrapping it into a lambda expression? 2. If no, then should it be considered as a bug?

Is there any plan to support macro in kotlin? It can save a lot of code for function define.

@vmironov: yes, this is how this is intended to work. normally you declare extension functions for a class inside another class only when you want to use those functions inside that class