What is the purpose of core routines in Kotlin for asynchronous programming, and how do they compare to traditional threading approaches?

This question is mainly asking two things. Firstly, it wants to understand what you know about the purpose of core routines in Kotlin when it comes to asynchronous programming. Secondly, it is interested in comparing this with traditional threading approaches. Therefore, in your response, you should:

1. Explain the purpose of core routines in Kotlin within the context of asynchronous programming.
2. Compare this with traditional threading approaches.
3. Illustrate understanding by using examples or practical applications if possible.

Core routines in Kotlin, more commonly referred to as coroutines, serve as a crucial tool in simplifying asynchronous programming in the language. They're primarily designed to manage long-running tasks that require waiting, like network or computation tasks, without blocking the main thread. This means a user interface, for instance, can still respond to the user while waiting for these tasks to complete.

In comparison, traditional threading techniques can be complex and cumbersome. Threads are usually expensive to start and keep running, and excessive context switching between them can degrade performance. Also, handling errors in a multithreaded environment can be quite complex.

Coroutines, on the other hand, are light-weight - thousands can be launched simultaneously without the risk of out-of-memory errors. The nature of their suspend function allows for non-blocking waiting, leading to fewer performance issues tied to thread context switching. Moreover, coroutines are flexible in that they can be cancelled easily and exceptions can be handled in a structured way, owing to the structured concurrency feature.

Core routines, also known as coroutines in Kotlin, symbolize the foundation for all asynchronism in the language. They allow programmers to write asynchronous code in a sequential style, making it much easier to read and understand. They combat the 'callback hell' that can often occur when chaining together multiple asynchronous calls.

When compared to traditional threading approaches, coroutines are far more efficient. Regular threads are costly, both regarding memory footprint and context switch times. Whenever a computation is suspended, a context switch requires saving and restoring the execution context, which can impact performance.

On the contrary, coroutines are lightweight in terms of memory and computational footprint. Their suspending operations do not block any thread but only suspend the coroutine itself. This feature can lead to highly scalable applications as it allows for numerous concurrent tasks using just a handful of system threads. Hence, coroutines offer a more modern and effective approach to asynchronous programming relative to traditional multithreading.