A modern programming language that makes developers happier.

kotlinlang

even if we for-go the "use a channel not a blockable queue", which is rather abstract, you could use standard kotlin `@ReplaceWith` for something like

```
launch {
  //replace 
  staticallyKnownAsBlockingQueueInstance.take()
  //with
  run(BLOCKABLE_THREAD_POOL) { staticallyKnownAsBlockingQueueInstance.take() }
}
```

inducing a compiler error at `BLOCKABLE_THREAD_POOL`... unlness kotlinx.coroutines can be updated to include such a dispatcher embedded in itself.

I'm not really sure that you can create a usable language that excludes all potential routes to shooting yourself in the foot. 
The aim of a good language should be to keep things as simple as possible so that any potential pit-falls can be identified via code review.

I agree, but java has _so much baggage_ at this point, I feel like some kind of comprehensive picture should be built about what kinds of tools can be employed to stop people from shooting themselves in the foot ("safeties"), how effective those safeties might be, and where they can be introduced. Coroutines is not the only example where they might be useful --code contracts is another. The thing is that coroutines might allow people doing functional testing to assume correctness despite some leviathan they've introduced through improper threading. Consider making IO blocking (eg WatchService.take()) on the Common pool. Such an application would work _until you're watching mas many directories as you have CPUS on your machine_. This is a nasty bug by any definition.

I donno, concurrency on the jvm scares me, and I think kotlin is positioned to do better than simply throw up its hands and say "heres another tool"