Jason5Lee's Blog

Handling Concurrency: Understanding Coroutines, Async/Await, Scheduling, and More

Sat, 24 Jun 2023 19:35:34 +0000

We often need to execute multiple tasks simultaneously in the program, such as a server handling multiple requests at the same time or a browser rendering the UI while performing I/O operations. As concurrency in our programs increases, technologies like asynchronous I/O, coroutines, and async/await are being used to support it. In this article, I’ll share my understanding of these technologies, hoping to help you comprehend and apply them.

The Fundamental Idea of Coroutines

The OS provides threads to run parallel tasks, but creating and scheduling a lot of threads can lead to high costs. Even with thread pooling, if a large amount of concurrency is needed at the same time, the number of threads in the thread pool must also be large.

My Understanding of OOP and FP

Tue, 30 Aug 2022 22:56:00 +0000

In my previous article, I discussed my understanding of programming languages in general. In this article, I will concentrate on explaining object-oriented programming (OOP) and functional programming (FP) as I understand them.

To summarize briefly: OOP is used to express intentions about universal objects, whereas functional programming primarily focuses on specific types of objects.

Encapsulation and Polymorphism

Before we delve into OOP and FP, let’s first talk about my understanding of encapsulation and polymorphism. These terms frequently appear in discussions about OOP and occasionally in FP. They might seem unusual at first, but they are tied to two elementary notions: the what and the how.

My Views on Programming Languages

Wed, 24 Aug 2022 22:29:00 +0000

There are many debates about the good and bad aspects of programming languages, and I will present my own viewpoints in this blog. I will also explain the keys to learning a programming language, and my understanding of design patterns.

Code as an Expression of Intent

When we write code, we use it to express our intentions. When we read code, we understand the author’s intentions through it. Similarly, a compiler or interpreter executes our intentions based on the code. Therefore, the primary function of code is to express intent.

Why pipeline does it right?

Thu, 24 Mar 2022 18:31:32 +0000

When I first learned F#, one design I didn’t get is that pipeline operators is used far more often than dot( . ). For example, for a C# expression like x.Select(n => ...) , you have to write x |> List.map (fun n -> ...) in F#, which looks verbose at the first sight. But after I’ve done more programmings and more thinkings, I figured out that the dot is abused in most of the languages and the pipeline does it right. Here is my thought.

Simulate exception in async Rust

Fri, 11 Mar 2022 22:40:23 +0000

WARNING: This may be a bad practice. The point of this article is just to share my idea.

Exception is a popular feature in many programming languages. Unlike Rust where errors are considered as a return value of the Err case of Result, in these languages errors are thrown like panic. The caller may catch the errors and process them similar to catch_unwind in Rust. Different people may have different preferences on the error handling style, but panic-unwind is always considered a bad practice and should be avoided if possible. So using exception-like error handling in Rust is impossible.

Customized trait object in Rust

Sat, 11 Jan 2020 21:03:30 +0000

I love the traits in Rust language. Rust uses one mechanism for both compile-time polymorphism and runtime polymorphism, which is elegant. However, the runtime polymorphism in Rust is not very flexible. Some traits cannot be used as a trait object, and it’s impossible to specify whether a method is resolved dynamically or statically. This shortage is reflected in my recursive function library RecurFn, and I develop a workaround, calling it customized trait object.