Tagged articles
Coroutines
86 articles · Page 1 of 1
The article explains why the traditional one‑request‑one‑thread model collapses at tens of thousands of connections due to memory, scheduling and cache costs, and shows how user‑space coroutine scheduling, stack‑less designs, Go's GMP model, Java virtual threads and CSP channels enable millions of concurrent connections with synchronous‑style code while highlighting trade‑offs and pitfalls.
CSPCoroutinesGo
0 likes · 21 min read

This article demystifies Kotlin's Flow, StateFlow, SharedFlow, and Channel by explaining their emission, storage, and loss mechanisms, illustrating common pitfalls with concrete code examples, and providing practical guidelines for choosing the right asynchronous data container in Android apps.
AndroidCoroutinesFlow
0 likes · 27 min read

TianQu is a pure Kotlin, coroutine-driven routing framework for Kotlin Multiplatform/Compose Multiplatform that supports HarmonyOS, Android, and iOS, featuring compile-time KSP scanning, type-safe navigation, cross-module service discovery, ViewModel lifecycle binding, concurrent preloading, and dynamic feature loading.
AndroidCompose MultiplatformCoroutines
0 likes · 34 min read

The article explains that a CPU continuously repeats four stages—fetch, decode, execute, and write‑back—while highlighting the role of registers, the differences between CISC and RISC instruction sets, how function calls build and tear down stack frames, and why user‑mode coroutines are far lighter than kernel threads.
ARMCPUCoroutines
0 likes · 28 min read

Google’s newly released Room 3.0 Alpha marks a landmark rewrite that transforms the Android‑only persistence library into a Kotlin Multiplatform solution, introducing package renaming, KSP‑only processing, coroutine‑first APIs, and experimental web support, while providing detailed migration steps and new features such as custom DAO return types.
CoroutinesKSPKotlin Multiplatform
0 likes · 12 min read

Async programming boosts efficiency by allowing tasks to run while waiting for I/O, and this guide explores eight common implementations—callbacks, Promises, async/await, event emitters, generators, coroutines, ReactiveX, and the Actor model—detailing their advantages, drawbacks, suitable scenarios, and production‑grade best practices.
CoroutinesPromisesactor model
0 likes · 10 min read

This article walks through thirteen typical Kotlin coroutine exception pitfalls, explains why errors propagate in structured concurrency, shows wrong and correct code patterns for launch, async, coroutineScope, supervisorScope, and other utilities, and provides concrete examples with outputs to help developers write robust coroutine code.
CoroutinesException HandlingKotlin
0 likes · 19 min read

The article argues that Java’s legacy null‑pointer crashes are driving teams toward Kotlin’s built‑in null safety, sealed classes, data classes, extension and scope functions, coroutines, Compose Multiplatform, and context parameters, making Kotlin the preferred JVM language for new projects by 2026.
Compose MultiplatformCoroutinesData Classes
0 likes · 7 min read

This article explains the debounce operator in Kotlin Flow, covering its core concept, practical scenarios like search input, multiple implementation styles—including fixed timeout, duration‑based, and dynamic debounce—along with internal mechanics, performance trade‑offs, best practices, common pitfalls, and real‑world code examples.
AndroidCoroutinesFlow
0 likes · 13 min read

This article explains the difference between synchronous and asynchronous execution in PHP, shows classic blocking code and non‑blocking examples, compares their pros and cons, and introduces Swoole coroutines as a way to achieve lightweight concurrency.
BackendCoroutinesPHP
0 likes · 7 min read

This article explains how PHP can handle high‑concurrency tasks by encapsulating functionality into independent units, demonstrating practical examples of multi‑process, multi‑thread, and coroutine approaches using the pcntl, pthread, and Swoole extensions to boost performance and resource management.
CoroutinesPHPmulti-process
0 likes · 5 min read

This article explains the differences and relationships between processes, threads, coroutines, and virtual threads, provides detailed Java code examples, compares their characteristics and performance, and offers practical guidance on choosing the right concurrency model for various scenarios.
CoroutinesJavaVirtualThreads
0 likes · 17 min read

This article explains the fundamental differences between processes, threads, coroutines, and virtual threads, shows how they are implemented in Java with code examples, compares their performance, and provides practical guidance on choosing the right concurrency model for various workloads.
CoroutinesJavaprocess
0 likes · 23 min read

This article demystifies the differences between concurrency, asynchrony, blocking and non‑blocking in Kotlin coroutines by providing runnable examples, experiments, and detailed analysis of thread usage, dispatcher behavior, and performance outcomes.
ConcurrencyCoroutinesKotlin
0 likes · 9 min read

This article demystifies the difference between blocking and non‑blocking coroutine work in Kotlin by providing runnable examples, measuring sequential, concurrent, and asynchronous execution, and revealing how thread usage, jobs, and dispatchers affect performance and true parallelism.
ConcurrencyCoroutinesKotlin
0 likes · 10 min read

This article compares Kotlin Channel and Flow, explains their design differences, outlines when to prefer each tool, provides step‑by‑step usage instructions, showcases four channel types, presents real‑world Android examples, and covers advanced patterns and exception handling for robust coroutine communication.
AndroidAsynchronous ProgrammingCoroutines
0 likes · 19 min read

This article compares Kotlin Channel and Flow, explains their distinct characteristics, shows when to prefer each in Android coroutine programming, provides step‑by‑step usage, multiple channel implementations, real‑world examples, advanced fan‑in/fan‑out patterns, and robust exception handling.
AndroidCoroutinesFlow
0 likes · 20 min read

This article explains what coroutines are, how PHP implements them with Generators and Fibers, compares asymmetric and symmetric designs, shows practical code examples, and outlines scenarios where coroutines improve state handling, lazy iteration, and cooperative multitasking in backend applications.
CoroutinesFibersPHP
0 likes · 17 min read

This article explores the significance of C++20, detailing its major new features such as modules and coroutines, explains how they improve compilation speed, code organization, and asynchronous programming, and provides practical examples and migration strategies for modern C++ development.
Asynchronous ProgrammingC++20Coroutines
0 likes · 41 min read

This article explains Java's lock mechanisms—including synchronized, ReentrantLock, and their JVM implementations—covers lock classifications, memory barriers, CAS, and compares them with Kotlin coroutine synchronization tools like Mutex, providing code examples and practical guidance for safe concurrent programming.
ConcurrencyCoroutinesJVM
0 likes · 22 min read

The article examines why relying solely on threads cannot achieve single‑machine million‑level concurrency, analyzing thread resource consumption, context‑switch overhead, and contrasting it with user‑space coroutine scheduling that offers predictable, low‑cost switches, making coroutines better suited for IO‑intensive high‑concurrency scenarios.
CoroutinesSchedulinghigh-concurrency
0 likes · 6 min read

This article highlights five common Kotlin coroutine pitfalls for Android developers—directly calling suspend functions in Views, misusing GlobalScope, sequential network calls, improper exception handling, and ignoring cancellation—while providing correct implementations and best‑practice guidelines to avoid them.
AndroidConcurrencyCoroutines
0 likes · 10 min read

The article analyzes why relying solely on operating‑system threads cannot easily achieve single‑machine million‑level concurrency, examining thread stack memory misconceptions, kernel‑level context‑switch costs, and how user‑space coroutine scheduling overcomes these limits.
ConcurrencyCoroutinesIO Multiplexing
0 likes · 6 min read

This article explains how to improve the speed and stability of bulk email delivery in modern web applications by using PHP asynchronous coroutines, detailing the underlying principles, advantages over synchronous sending, and providing a complete code example with Swoole, PHPMailer, and channel coordination.
BackendCoroutinesPHP
0 likes · 5 min read

The article traces Java’s concurrency evolution from heavyweight thread‑per‑request and complex reactive models to JDK 21’s virtual threads, which act as stack‑ful coroutines offering lightweight, heap‑allocated threads, full stack traces, and blocking‑I/O compatibility while preserving the familiar thread API.
Async ProgrammingConcurrencyCoroutines
0 likes · 24 min read

This guide introduces asynchronous Python, explaining why async improves speed, how coroutines and the event loop work, and provides practical examples and common pitfalls to help developers write faster, more efficient I/O‑bound code.
Asynchronous ProgrammingCoroutinesPython
0 likes · 14 min read

This article analyzes Kuaishou's development of a Java 17 transparent coroutine solution, detailing its architectural evolution, scheduling and I/O optimizations, performance gains in cloud‑native high‑load environments, and future directions for large‑scale production deployment.
CoroutinesIO optimizationJava
0 likes · 18 min read

This article introduces twelve advanced Python features—including generators, context managers, metaclasses, descriptors, coroutines, data classes, type annotations, multiple inheritance with mixins, exception chaining, modules and packages, itertools, and regular expressions—explaining their purpose and providing clear code examples to illustrate each concept.
Advanced FeaturesCoroutinesData Classes
0 likes · 8 min read

This article explains the fundamentals of C++20 coroutines, describing their lightweight asynchronous execution model, key language constructs such as co_await, co_yield, and co_return, the underlying components like promise objects and coroutine handles, and demonstrates real‑world usage through comprehensive code examples for networking, file I/O, generators, and task scheduling.
C++20Coroutinesco_await
0 likes · 32 min read

This guide explains Webman 5's support for Fiber, Swoole, and Swow coroutine drivers, shows how to install the required packages, configure each worker to use a specific driver, provides complete PHP code examples for Workerman and Webman, demonstrates starting the server, checking its status, and highlights compatibility constraints between Swow and Swoole.
CoroutinesFiberPHP
0 likes · 12 min read

This article explains how to combine Kotlin coroutines, Flow, Retrofit, and OkHttp to create a clean, reactive, and maintainable network request framework for Android applications, covering concepts, core principles, and practical code examples.
AndroidCoroutinesFlow
0 likes · 16 min read

The article compares Go’s stackful, green‑thread model with Rust’s stackless, future‑based approach, explaining how each runtime schedules tasks, the memory overhead of goroutine stacks (2 KiB minimum in Go 1.22), the challenges of async‑await integration, and why Rust’s performance gains come with a fragmented ecosystem.
CoroutinesGoMemory
0 likes · 8 min read

This article walks through Python generators in depth—covering basic yield behavior, the __next__, send, throw, and close methods, pre‑activation states, delegation with yield from, generator expressions pitfalls, and their role in coroutine implementation—while briefly recounting a personal conflict that sparked the write‑up.
CoroutinesPythonSend
0 likes · 28 min read


21CTONov 22, 2024 · Fundamentals
Chief designer Michail Zarečenskij explains Kotlin’s evolution from a Java alternative to a multiplatform language, its ongoing reliance on JVM interoperability, hopes for Project Valhalla, the impact of Project Loom on coroutines, and upcoming features slated for the next Kotlin release.
CoroutinesJVMKotlin
0 likes · 7 min read

This article compares coroutines and threads for high‑concurrency and I/O‑intensive workloads, summarizes multithreading fundamentals, presents performance‑critical code examples, and discusses JVM memory, locking, middleware, and various optimization techniques for backend systems.
ConcurrencyCoroutinesJVM
0 likes · 7 min read

This article compares coroutines and threads for high‑concurrency and I/O‑intensive workloads versus CPU‑bound tasks, discusses Kotlin coroutine adoption, presents multithreading fundamentals, highlights performance pitfalls like System.currentTimeMillis, and offers code examples and optimization strategies for backend developers.
CoroutinesJavaKotlin
0 likes · 8 min read

This guide introduces Swow—a lightweight C core and PHP‑based library for high‑performance network programming—covers its key features, step‑by‑step installation, coroutine concepts, channel communication, and provides practical HTTP and TCP server code samples for PHP developers.
BackendCoroutinesPHP
0 likes · 9 min read

This article introduces Python coroutines, explains their basic concepts and advantages, demonstrates how to implement them using async and await, and provides practical examples for concurrent HTTP requests and resource management, illustrating the underlying mechanics of async def, await, and the asyncio library.
Async/AwaitCoroutinesPython
0 likes · 6 min read

The article examines Go's coroutine architecture and its GMP (Goroutine-Machine-Processor) model, tracing coroutine history, comparing kernel, user, and hybrid thread models, and detailing G, M, and P components, scheduling principles, work-stealing, preemption, and runtime implementation that give Go high concurrency and low latency.
ConcurrencyCoroutinesGMP model
0 likes · 37 min read

Kotlin Multiplatform enables developers to share a single Kotlin codebase across Android, iOS and the new Harmony Next OS—avoiding costly full rewrites—by converting Harmony OS TypeScript definitions to Kotlin, compiling to JavaScript or native binaries, though challenges remain in debugging, library compatibility, bundle size and threading support.
CoroutinesCross-platform DevelopmentHarmonyOS
0 likes · 18 min read

This article examines why Kotlin coroutine concepts are hard to explain, identifies common shortcomings in existing tutorials, and proposes a step‑by‑step approach that starts from basic thread concepts, uses incremental examples, and introduces task‑flow techniques to clarify coroutine behavior.
ConcurrencyCoroutinesKotlin
0 likes · 15 min read

This article analyzes the shortcomings of existing Kotlin coroutine tutorials and presents a step‑by‑step guide to building a lightweight coroutine framework from scratch, covering thread basics, CoroutineScope, launch, delay, resume, state‑machine logic, withContext, async, and Deferred with complete code examples.
Asynchronous ProgrammingCoroutinesCustom Implementation
0 likes · 15 min read

This article explains the core concepts of Kotlin coroutines, including what they are, how they differ from threads, the mechanics of suspension and resumption, the role of the suspend keyword, and practical code examples that illustrate their usage in Android development.
ConcurrencyCoroutinesKotlin
0 likes · 20 min read

This article explains how to boost PHP application performance by installing the Swoole extension and using its coroutine API to run concurrent tasks such as HTTP requests and database queries, providing code examples and configuration steps for effective backend concurrency.
ConcurrencyCoroutinesPHP
0 likes · 4 min read

This article provides a comprehensive introduction to C++20 coroutines, covering fundamental concepts, stackful versus stackless implementations, detailed code demos—including a simple coroutine, a generator for Fibonacci numbers, and a task framework—while explaining the underlying compiler transformations and practical usage.
C++20CoroutinesStackless
0 likes · 31 min read

The article systematically distinguishes unrecoverable errors from recoverable exceptions and surveys five major handling strategies—global error codes, return‑value conventions, parameter‑based collectors, language‑level exception mechanisms, and OS‑level support—concluding that the optimal approach depends on performance constraints, code‑base design, and portability requirements.
CoroutinesProgramming Paradigmsbackend-development
0 likes · 47 min read

This article introduces Python coroutines and asynchronous programming using the asyncio module, explains key concepts such as event loops and non‑blocking I/O, and provides ten detailed code examples that demonstrate creating, managing, and synchronizing async tasks for improved performance.
Asynchronous ProgrammingBackendCoroutines
0 likes · 7 min read

To merge Bilibili’s UGC and OGV playback pages, the team built a multi‑scope architecture that aligns Dagger‑managed dependency‑injection components with Kotlin CoroutineScopes—PageScope, BizScope, and VideoPlayScope—so each business module is instantiated only when needed, automatically disposed with its parent lifecycle, and remains memory‑leak‑free.
AndroidCoroutinesDAgger
0 likes · 19 min read

By converting Android network calls from callback‑based listeners to Kotlin coroutines, the code becomes sequential, eliminates duplicated UI‑state checks, centralizes loading handling, supports parallel requests with async/await, and integrates with lifecycleScope for automatic cancellation, greatly improving readability and safety.
AndroidAsync ProgrammingCoroutines
0 likes · 15 min read

This article explores three Python coroutine libraries - asyncio, gevent, and trio - providing 10 practical code examples demonstrating their use in asynchronous programming for tasks like IO operations, network requests, file handling, and more.
Asynchronous ProgrammingConcurrent ProgrammingCoroutines
0 likes · 5 min read

The article explains Java's new Virtual Thread (coroutine) feature, compares the traditional thread‑per‑request model with asynchronous and coroutine approaches, discusses Little's Law for scalability, and outlines the benefits and pitfalls of using coroutines in server‑side Java applications.
Async ProgrammingConcurrencyCoroutines
0 likes · 10 min read

This guide introduces Swoole, a high‑performance asynchronous PHP framework for IoT, and walks through installing the extension, building TCP and WebSocket servers, performing asynchronous file I/O, and leveraging coroutines with complete code examples.
CoroutinesIoTPHP
0 likes · 5 min read

This article explains the underlying principles of Swoole coroutines, compares them with Go's goroutine model, outlines important usage considerations, contrasts Swoole with Workerman, describes coroutine communication methods, and provides practical PHP performance optimization tips.
CoroutinesGoPHP
0 likes · 8 min read

This article explains Python coroutines, compares them with multithreading, outlines their suitable scenarios, and demonstrates how using the httpx library for asynchronous HTTP requests can dramatically improve request performance in backend testing, backed by concrete code examples and benchmark results.
CoroutinesPythonhttpx
0 likes · 7 min read

The article uncovers a lock‑induced latency in Retrofit’s service‑method cache during cold‑start, demonstrates how moving the synchronization to a class‑level lock and customizing Retrofit.create eliminates the bottleneck, and then shows how dynamic‑proxy hooks combined with Kotlin coroutines can add transparent caching and low‑intrusion BFF aggregation without altering the library.
AndroidBFFCoroutines
0 likes · 21 min read

This article thoroughly explains libunifex’s sender/receiver model for C++ asynchronous programming, covering its design goals, module structure, pipeline composition, key functions like schedule, then, sync_wait, and the connect/start mechanisms, while demonstrating practical examples and integration with C++20 coroutines and cancellation support.
Asynchronous ProgrammingC++Cancellation
0 likes · 16 min read

This article explains how Kotlin coroutines work under the hood by turning callback‑based code into state‑machine continuations, demonstrates the role of the Continuation interface and suspend functions, and shows practical patterns such as suspendCoroutine, custom DSLs, and a PendingData utility for managing asynchronous UI flows like home‑page pop‑ups in Android.
AndroidContinuationCoroutines
0 likes · 29 min read

This article explains why simple serial file reads are slow, compares multithreaded and event‑loop based approaches, introduces the Reactor pattern and callbacks, and finally shows how coroutines provide a synchronous‑style solution for efficient, non‑blocking I/O processing.
CoroutinesReactor Patternasynchronous I/O
0 likes · 12 min read

This article dissects the Kotlin coroutine implementation by decompiling a simple coroutine, explaining how the compiler transforms suspend functions into state‑machine classes, how launch creates an AbstractCoroutine, how the dispatcher intercepts and schedules execution, and how the coroutine is suspended and later resumed through Continuation mechanisms.
ConcurrencyCoroutinesKotlin
0 likes · 16 min read

This article provides a comprehensive introduction to Kotlin Coroutines, covering their history, core concepts like CoroutineContext, Dispatchers, Job, Deferred, and suspend functions, and demonstrates practical Android usage with code examples for launching coroutines, handling concurrency, networking, Room database operations, timeouts, exception handling, and Flow-based timers.
AndroidConcurrencyCoroutines
0 likes · 21 min read

This article walks through C++20 coroutines with clear explanations, three runnable examples, deep dives into promise_type, coroutine_handle, co_await, co_yield and co_return, and shows how to build both void‑returning and int‑returning coroutines while illustrating the compiler‑generated control flow.
Async ProgrammingC++C++20
0 likes · 21 min read

This article details Ctrip’s experience integrating Kotlin Multiplatform Mobile (KMM) into its Android and iOS ticketing apps, covering background selection, overall architecture, Android and iOS integration steps, code examples, challenges such as concurrency model differences, and ecosystem considerations.
AndroidCoroutinesKMM
0 likes · 33 min read

This article demonstrates how Kotlin Flow and Channel can address common Android development challenges such as ViewModel‑View communication and event handling, compares alternatives like LiveData and RxJava, and presents a practical MVI architecture implementation with code examples.
AndroidCoroutinesFlow
0 likes · 24 min read

This article explains how to combine Retrofit with Kotlin coroutines on Android, compares the traditional RxJava method with coroutine-based implementations, and presents two encapsulation techniques—using a DSL and leveraging CoroutineExceptionHandler—to simplify asynchronous network calls and centralize error handling.
AndroidCoroutinesDSL
0 likes · 14 min read

This article explains two Kotlin‑based network request wrappers for Android that reduce boilerplate by using LiveData, Retrofit, OkHttp and coroutines, compares their design trade‑offs, provides complete Activity, ViewModel, Repository and BaseRepository code samples, and shows how to handle loading, success, error and multiple data sources in a clean MVVM architecture.
AndroidCoroutinesKotlin
0 likes · 10 min read

This article explains how Kotlin coroutines simplify asynchronous programming on Android by using suspension, detailing core concepts, APIs, dispatchers, suspend functions, and the underlying implementation through decompiled bytecode and continuation‑passing style, complemented by practical code examples and execution logs.
AndroidConcurrencyCoroutines
0 likes · 34 min read

This article explains Kotlin coroutine fundamentals, creation, launch and async usage, suspension functions, withContext, and compares coroutine-based implementations with RxJava in Android development, providing code examples and best‑practice guidance, including performance considerations and migration advice.
AndroidConcurrencyCoroutines
0 likes · 18 min read

This article explains the fundamentals of operating‑system processes and threads, how the OS scheduler enables concurrent execution, the cost of context switches, and why Go implements lightweight user‑level goroutines to achieve efficient concurrency in modern applications.
CoroutinesGoOS Scheduler
0 likes · 11 min read

This article explains how Python’s coroutine model evolved from Tornado’s single‑threaded async/await support to a generator‑based micro‑framework that uses IO multiplexing, callbacks, futures and stack‑based call‑chain handling to achieve non‑blocking network programming.
CoroutinesIO MultiplexingPython
0 likes · 21 min read

This article explains how Retrofit 2.6.0 adds support for Kotlin suspend functions by detecting the Continuation parameter, determining the return type, and generating appropriate CallAdapter implementations such as SuspendForResponse and SuspendForBody to integrate coroutine handling with OkHttp.
CallAdapterCoroutinesKotlin
0 likes · 12 min read

This article explains how Ctrip's flight Android app refactored its home page using Kotlin coroutines, Jetpack AAC components, and MVVM architecture, detailing the technical and business background, code patterns, production issues, and lessons learned for large‑scale mobile development.
AndroidCoroutinesJetpack
0 likes · 20 min read

This article provides a comprehensive source‑code walkthrough of Kotlin coroutines, explaining how launch creates a coroutine, how the compiler transforms suspend functions into state‑machine classes, and detailing the mechanisms of suspension and resumption through Continuation, Dispatchers, and the coroutine scheduler.
ConcurrencyCoroutinesDispatcher
0 likes · 46 min read

This article explains how to replace complex Java NIO callback code with lightweight Quasar coroutines to boost throughput, simplify asynchronous programming, and reduce thread usage in high‑concurrency backend systems, while also covering integration with Netty, RPC, and handling of blocking operations.
CoroutinesJavaQuasar
0 likes · 17 min read

This article provides a comprehensive guide to Kotlin coroutines, covering their concepts, creation methods (launch, runBlocking, async), nesting, suspend functions, cancellation, timeout handling, dispatchers, scopes, underlying implementation, and a practical Retrofit‑OkHttp example for asynchronous network requests in Android.
CoroutinesKotlinRetrofit
0 likes · 20 min read

The article shares personal experiences with Kotlin coroutines, highlighting debugging challenges, loss of context across threads, pitfalls of using ThreadLocal, synchronization issues, and performance trade‑offs, ultimately explaining why the author stopped using coroutines for server‑side development.
CoroutinesKotlinbackend development
0 likes · 9 min read

This article explains Python's Global Interpreter Lock, introduces generators and the yield/yield from expressions, demonstrates how they enable coroutine-based asynchronous programming, and provides practical asyncio examples using @asyncio.coroutine, async/await, and futures for efficient I/O handling.
Async/AwaitCoroutinesgenerators
0 likes · 13 min read

This article clarifies core operating‑system concepts such as tasks, jobs, hyper‑threading, threads, processes, fibers, monitors, and coroutines, explaining their differences, relationships, and how they enable efficient concurrent execution.
ConcurrencyCoroutinesprocesses
0 likes · 8 min read

The article demonstrates that Kotlin coroutines on the JVM are merely a convenient API layered on traditional Java threads rather than true lightweight coroutines, contrasting them with Go’s M:N goroutine scheduling, and discusses experimental Kotlin‑Native and OpenJDK Loom projects that aim to provide genuine coroutine support.
CoroutinesGoJVM
0 likes · 20 min read

This article explains how Alibaba’s Wisp2 brings Go‑like coroutine performance to Java by replacing OS thread scheduling, details its design, shows benchmark improvements over traditional thread‑pool models, compares it with Project Loom, and provides practical code snippets for enabling Wisp2 in production.
Asynchronous ProgrammingConcurrencyCoroutines
0 likes · 16 min read

This article explains how Kotlin coroutines work in Android, comparing launch and async, detailing the role of suspend functions, thread switching with Dispatchers, and how the coroutine framework handles suspension and resumption to simplify asynchronous programming.
ConcurrencyCoroutinesSuspend
0 likes · 13 min read

The article explains how resource obfuscation with andResGuard removes META‑INF service files needed for the Android Main dispatcher, causing coroutines to silently fail after withContext calls, and shows that preserving the META‑INF/services directory restores proper coroutine execution.
APKAndroidCoroutines
0 likes · 8 min read

This article introduces essential programming fundamentals, covering Unix system architecture, the distinction between system calls and library functions, user and kernel modes, the execution flow of a simple hello‑world program, and core concepts such as processes, threads, coroutines, and parent‑child process sharing.
Coroutinesoperating systemprocesses
0 likes · 7 min read

Both ES6 generators and node-fibers enable coroutine-style asynchronous flow in Node.js without blocking the entire process, but they differ in syntax, safety, flexibility, and invasiveness, prompting developers to weigh the trade‑offs between readability and minimal code intrusion.
CoroutinesFibersNode.js
0 likes · 3 min read

This tutorial explains Python's asynchronous programming model—including coroutines, the yield‑from syntax, async/await keywords, and event‑loop management—while providing a complete, runnable example that fetches Reddit JSON data concurrently using aiohttp.
Async/AwaitCoroutinesPython
0 likes · 11 min read

This article explains how to achieve asynchronous MySQL queries in PHP by leveraging mysqlnd's async functions and PHP generators, compares synchronous and asynchronous execution times, provides a complete coroutine‑based example, and discusses performance considerations and limitations.
CoroutinesDatabase PerformanceMySQL
0 likes · 7 min read

This article explores Linux process and thread fundamentals, traditional network service models, the C10K challenge, and advanced techniques such as epoll, event‑driven designs, and coroutine‑based asynchronous programming to improve scalability and performance.
CoroutinesLinuxprocesses
0 likes · 27 min read
