In a simple words, async’s philosophy is - while waiting, do something!

Async, or asynchronous is not as an asing things in programming. However, due to no real world use case for utilization of the concept, I tend to ignore it in my codes. Then it has became my concerns in my current working project as it required me to build a vast and robust pipeline that is operated efficiently and relatively faster.

Why Use

• Time is money

• Speed

• Optimization

When to Use

1. Use it whenever you have a function that took so much time, yet you want other function to run int the background or while waiting the slow guy to complete.

2. Use it when you want to increase the efficiency of the code, increase the potential and speed of the operation by not blocking other function(s).

The Burger Analogy

Below is the approaches to complete any process or operation, or any task in life. To understand this, imagine a situation when a man need to cook a burger in a restaurant. The man need to completed 10 set of burgers by following the common cooking process.

Pure Sync

• A man cooking a burger sequentially (single thread)

1. Man cook a patty with no timer.

2. Man waiting until the patty cooks and cannot do the next step until the patty is cooked. (blocking)

3. Once cooked, man slice the bread.

4. Man then frying the fries with no timer features. Man waiting until fries is completely cooked. (blocking)

5. Man put lettuce and mayo on the bread and stack up with the patty.

6. Man put fries as side dish.

7. Man do step 1 to 4, until it completed 10 burgers.

8. Man tired.

Took so so much time. :(

Pure Async

• A man cooking a burger (single thread)

1. Man cook a patty.

2. While waiting patty to cook, man slice a bread.

3. Man go flip the patty and set a timer for five minutes.

4. While waiting patty cook, man fry fries in a fryer with timer for 3 minutes.

5. Man put lettuce on the bread.

6. While waiting the patty cook, fry timer ended. Man take the french fries and put in the plate.

7. Patty cooked, man put patty on the stacked bread with lettuce.

Fast and efficient.

Pure Async + Multithreading

• 4 men cooking a burger (4 threads)

1. Man-A cook a patty, Man-B slice bread, Man-C frying fries, Man-D arrange the lettuce.

2. While patty cook, Man-B take lettuce on bread, Man-C put the fries on the plate.

3. Patty cook, Man B took patty and stack on bread.

4. Complete.

Faster, but more complex to control more men.

---

Coding Mindset

1. Do async function for function that potentially taking too much time.

2. Wrap the expression(s) in a function. Atomize it.

3. Prefix with async and await the async-ing function.

Async Code

In Python, we will handle the async function with asyncio Package and it will do all the magics behind it.

Basics

Terms

• coroutine - when it is async, the function will be call as the coroutine object or function

Task

Task is fancy terms for the function you want to execute. Task is optional. You can explicitly create it with with asyncio.create_task() or, directly run it with asyncio.run() or asyncio.gather() + asyncio.run() for multiple async function.

• asyncio.create_task() — create task immediately, can run later with await if you want, independent task, cancellable

• asyncio.gather() — gather all coroutine function together, don’t want run the function later, non cancellable, return list

Non-dependent async function

• simple coroutine functions with asyncio.run() and asyncio.gather()

async function():
    asyncio.sleep(10) # just to simulate a time consuming function
    return "a"
async function()_1:
    asyncio.sleep(10)
    return "b"
async function()_2:
    asyncio.sleep(10)
    return "c"
async function()_3:
    asyncio.sleep(10)
    return "b"


async def main():
    # singlefunction
    asyncio.run(function()) 

    # multiple async function
    asynction.gather(function_1(), function_2(), function_3())

# run the corouting function
asyncio.run(main())

Dependent function

• function_a dependent on function_b to complete first. Hence the async is contagious.

import asyncio
async def do_things():
    print("Currently doing things...")
    asyncio.sleep(100)  # fake a function that took so much time!
    return "yes"

async def process_output(out):
    if out == "yes":
        return "completed"

def check_something():
    out = await do_things()
    process = await process_output(out) # need to await coz do_things took time to complete
    return process

asyncio.run(check_somoething)
# await check_something() # notebook
Output:
"yes"

Off-loading blocking tasks

• There is sync function that will blocked the operation (legacy, or unsupported)

  asyncio.to_thread() | asyncio.loop.run_in_executor()

function():return "a" # sync, legacy or unsupported for async
async function()_1:return "b"
async function()_2:return "c"
async function()_3:return "b"


async def main():
    # singlefunction
    asyncio.run(asyncio.to_thread(function())) # or loop.run_in_executor()

    # multiple async function
    asynction.gather(function_1(), function_2(), function_3())

# run the corouting function
asyncio.run(main())

Potential Bugs

If pure async approach is possible, why there is blocking function?

1. Legacy sync function.

2. Unsupported async feature in package.

3. Some function easily handled as sync.

Overwhelming. How to start?

1. For time consuming function, make it async. Use async in front of def.

2. Calling async function require you to use await. Hence include it if it is called.

3. Start with asyncio.run() for easy execution of async function. Then can try asyncio.gather([list of async function]) + asyncio.run() for multiple async functions.

4. Once comfortable, implement intermediate async feature, such async time base, prioritization base, and queue.

Conclusion

I hope this will help the beginners or any level of programmer to understand the async concept. If you have any commenta, please leave the comment below. I appreciate it. Thank you.