These changes are already available for you to try in the 1.4.0-RC release!<\/p>\n
![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2020\/07\/Kotlin-1.4-RC_banners_Blogpost.png\")
<\/p>\n
Let\u2019s dive into details.<\/p>\n
Debugging coroutines<\/h2>\n
Coroutines are great for asynchronous programming (but not only for that), and many people already use them or are starting to use them. When you write code with coroutines, however, trying to debug them can be a real pain. Coroutines jump between threads. It can be difficult to understand what a specific coroutine is doing or to check its context. And in some cases, tracking steps over breakpoints simply doesn\u2019t work. As a result, you have to rely on logging or mental effort to debug the code with coroutines. To address this issue, we\u2019re introducing new functionality in the Kotlin plugin that aims to make debugging coroutines much more convenient.<\/p>\n
The Debug Tool Window<\/em> now contains a new Coroutines<\/em> tab. It is visible by default, and you can switch it on and off:<\/p>\n In this tab, you can find information about both currently running and suspended coroutines. The coroutines are grouped by the dispatcher they are running on. If you started a coroutine with a custom name, you can find it by this name in the Tool Window. In the following example, you can see that the main coroutine is running (we\u2019ve stopped on a breakpoint inside it), and the other four coroutines are suspended:<\/p>\n With the new functionality, you can check the state of each coroutine and see the values of local and captured variables. This also works for suspended coroutines!<\/p>\n In this example, we check the values of the local variables of suspended coroutines:<\/p>\n Choose a suspended coroutine (click You can now see a full coroutine creation stack, as well as a call stack inside the coroutine:<\/p>\n Use the \u2018Get Coroutines Dump\u2019 option to get a full report containing the state of each coroutine and its stack:<\/p>\n At the moment, the coroutines dump is still rather simple, but we\u2019re going to make it more readable and helpful in future versions.<\/p>\n Note that to make the debugger stop at a given breakpoint inside a coroutine, this breakpoint should have the \u201cSuspend: All\u201d option chosen for it:<\/p>\n To try this new functionality for debugging coroutines, you need to use the latest version of kotlinx.coroutines<\/a>, 1.3.8-1.4.0-rc<\/strong>, and the latest version of the Kotlin plugin (e.g. 1.4.0-rc<\/strong>-release-IJ2020.1-2<\/strong>).<\/p>\n The functionality is available only for Kotlin\/JVM. If you encounter any problems (please don\u2019t forget to share the details with us!), you can switch it off by opening Build, Execution, Deployment | Debugger | Data Views | Kotlin<\/a> in Preferences<\/a> and choosing Disable coroutines agent<\/em>. For now, we\u2019re releasing this functionality for debugging coroutines in the experimental<\/em> state, and we\u2019re looking forward to your feedback!<\/p>\n In Kotlin 1.4, you can define recursive functions and invoke them even when the call depth is greater than 100,000, using the standard library support based on coroutines!<\/p>\n Let\u2019s first look at an ordinary recursive function, whose usage results in a We\u2019ll use a simple binary tree, where each The depth of the tree is the length of the longest path from its root to its child nodes. It can be computed using the following recursive function:<\/p>\n The tree depth is the maximum of the depths of the left and right children increased by one. When the tree is empty it\u2019s zero.<\/p>\n This function works fine when the recursion depth is small:<\/p>\n However, if you create a tree with a depth greater than 100,000, which in practice is not so uncommon, you\u2019ll get The problem is that the call stack gets too large. To solve this issue, you can use a VM option to increase the maximum stack size. However, while this might work for specific use cases, it\u2019s not a practical solution for the general case.<\/p>\n Alternatively, you can rewrite the code and store results for intermediate calls by hand in the heap rather than on the stack. This solution works in most cases and is common in other languages. However, the resulting code becomes non-trivial and complicated, and the beauty and simplicity of the initial function are lost. You can find an example here<\/a>.<\/p>\n Kotlin now provides a clean way to solve this problem based on the coroutines machinery.<\/p>\n The Kotlin library now includes the definition You can compare the two versions, the initial one and the one using Understanding how As always, you can try Kotlin online<\/strong> at play.kotl.in<\/a>.<\/p>\n In IntelliJ IDEA<\/strong>, you can update the Kotlin Plugin to version 1.4.0-RC. See how to do this<\/a>.<\/p>\n If you want to work on existing projects that were created before installing the preview version, you need to configure your build for the preview version in Gradle or Maven<\/a>. Note that unlike the previous preview versions, Kotlin 1.4.0-RC is also available directly from Maven Central. This means you won\u2019t have to manually add the You can download the command-line compiler<\/strong> from the Github release page<\/a>.<\/p>\n We\u2019ll be very thankful if you find and report bugs to our issue tracker<\/a>. We\u2019ll try to fix all the important issues before the final release, which means you won\u2019t need to wait until the next Kotlin release for your issues to be addressed.<\/p>\n You are also welcome to join the #eap channel<\/a><\/em> in Kotlin Slack<\/a> (get an invite here<\/a>). In this channel, you can ask questions, participate in discussions, and get notifications about new preview builds.<\/p>\n Let\u2019s Kotlin!<\/p>\n","protected":false},"author":42,"featured_media":59243,"comment_status":"open","ping_status":"closed","template":"","categories":[907],"tags":[91],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/en\/wp-json\/wp\/v2\/kotlin\/59159"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/en\/wp-json\/wp\/v2\/kotlin"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/en\/wp-json\/wp\/v2\/types\/kotlin"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/en\/wp-json\/wp\/v2\/users\/42"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/en\/wp-json\/wp\/v2\/comments?post=59159"}],"version-history":[{"count":2,"href":"https:\/\/blog.jetbrains.com\/en\/wp-json\/wp\/v2\/kotlin\/59159\/revisions"}],"predecessor-version":[{"id":139457,"href":"https:\/\/blog.jetbrains.com\/en\/wp-json\/wp\/v2\/kotlin\/59159\/revisions\/139457"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/en\/wp-json\/wp\/v2\/media\/59243"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/en\/wp-json\/wp\/v2\/media?parent=59159"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/en\/wp-json\/wp\/v2\/categories?post=59159"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/en\/wp-json\/wp\/v2\/tags?post=59159"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/en\/wp-json\/wp\/v2\/cross-post-tag?post=59159"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2020\/07\/image-1595615740412.png\")
<\/p>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2020\/07\/image-1595616002134.png\")
<\/p>\n\r\nimport kotlinx.coroutines.*\r\n\r\nfun main() = runBlocking {\r\n repeat(4) {\r\n launch(Dispatchers.Default + CoroutineName("Default-${'a' + it}")) {\r\n delay(100)\r\n val name = coroutineContext[CoroutineName.Key]?.name\r\n println("I'm '$name' coroutine")\r\n }\r\n }\r\n delay(50)\r\n \/\/ breakpoint\r\n println("I'm the main coroutine")\r\n}\r\n<\/pre>\n\r\nimport kotlinx.coroutines.*\r\n\r\nfun main() = runBlocking<Unit> {\r\n launch {\r\n val a = 3\r\n delay(300)\r\n println(a)\r\n }\r\n launch {\r\n val b = 2\r\n delay(200)\r\n println(b)\r\n }\r\n launch {\r\n val c = 1\r\n delay(100)\r\n \/\/ breakpoint here:\r\n println(c)\r\n }\r\n}\r\n<\/pre>\ninvokeSuspend<\/code> to see its state on that point) and the Variables<\/code> tab will show you the state of the local variables:<\/p>\n![](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2020\/07\/image-1595617185391.png\"\ndata-gif-src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2020\/07\/coroutines-debugger.gif\")
<\/p>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2020\/07\/image-1595615610849.png\")
<\/p>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2020\/07\/image-1595616044215.png\")
<\/p>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2020\/07\/image-1595616082379.png\")
<\/p>\nDefining deep recursive functions using coroutines<\/h2>\n
StackOverflowError<\/code> when the recursion depth gets too high. After that, we\u2019ll discuss how you can fix the problem and rewrite the function using the Kotlin standard library.<\/p>\nTree<\/code> node has a reference to its left<\/code> and right<\/code> children:<\/p>\n\r\nclass Tree(val left: Tree?, val right: Tree?)\r\n<\/pre>\n
\r\nfun depth(t: Tree?): Int =\r\n if (t == null) 0 else maxOf(\r\n depth(t.left),\r\n depth(t.right)\r\n ) + 1\r\n<\/pre>\n
![\"\"\/](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2020\/07\/image-1595616140938.png\")
<\/p>\n\r\nclass Tree(val left: Tree?, val right: Tree?)\r\n\r\nfun depth(t: Tree?): Int =\r\n if (t == null) 0 else maxOf(\r\n depth(t.left),\r\n depth(t.right)\r\n ) + 1\r\n\r\nfun main() {\r\n\/\/sampleStart\r\n val tree = Tree(Tree(Tree(null, null), null), null)\r\n println(depth(tree)) \/\/ 3\r\n\/\/sampleEnd\r\n}\r\n<\/pre>\nStackOverflowError<\/code> as a result:<\/p>\n\r\nclass Tree(val left: Tree?, val right: Tree?)\r\n\r\nfun depth(t: Tree?): Int =\r\n if (t == null) 0 else maxOf(\r\n depth(t.left),\r\n depth(t.right)\r\n ) + 1\r\n\/\/sampleStart\r\nfun main() {\r\n val n = 100_000\r\n val deepTree = generateSequence(Tree(null, null)) { prev ->\r\n Tree(prev, null)\r\n }.take(n).last()\r\n\r\n println(depth(deepTree))\r\n}\r\n\/*\r\nException in thread "main" java.lang.StackOverflowError\r\n at FileKt.depth(File.kt:5)\r\n ...\r\n*\/\r\n\/\/sampleEnd\r\n<\/pre>\nDeepRecursiveFunction<\/code>, which models recursive calls using the suspension mechanism:<\/p>\n\r\nclass Tree(val left: Tree?, val right: Tree?)\r\n\r\n@OptIn(ExperimentalStdlibApi::class)\r\nval depthFunction = DeepRecursiveFunction<Tree?, Int> { t ->\r\n if (t == null) 0 else maxOf(\r\n callRecursive(t.left),\r\n callRecursive(t.right)\r\n ) + 1\r\n}\r\n\r\n@OptIn(ExperimentalStdlibApi::class)\r\nfun depth(t: Tree) = depthFunction(t)\r\n\r\nfun main() {\r\n val n = 100_000\r\n val deepTree = generateSequence(Tree(null, null)) { prev ->\r\n Tree(prev, null)\r\n }.take(n).last()\r\n\r\n println(depth(deepTree)) \/\/ 100000\r\n}\r\n<\/pre>\nDeepRecursiveFunction<\/code>, to make sure that the logic remains the same. Your new function now becomes a variable of type DeepRecursiveFunction<\/code>, which you can call using the ‘invoke’ convention<\/a> as depthFunction(t)<\/code>. The function body now becomes the body of the lambda argument of DeepRecursiveFunction<\/code>, and the recursive call is replaced with callRecursive<\/code>. These changes are straightforward and easy to make. Note that while the new depth<\/code> function uses coroutines under the hood, it is not itself a suspend<\/code> function.<\/p>\nDeepRecursiveFunction<\/code> is implemented is interesting, but it is not necessary in order for you to use it and benefit from it. You can find the implementation details described in this blog post<\/a>.<\/p>\nDeepRecursiveFunction<\/code> is a part of the Kotlin standard library, not part of the kotlinx.coroutines<\/code> library, since it\u2019s not about asynchronous programming. At the moment this API is still experimental, so we\u2019re looking forward to your feedback!<\/p>\nHow to try it<\/h2>\n
kotlin-eap<\/code> repository to your build files. <\/p>\nShare your feedback<\/h2>\n