Asynchronous Programing

• f = open('/home/user/rndFile.txt', 'r'): requests Operating System to lookup a file using specified path in read-only mode.
• first_line = f.readline(): requests OS again to read the file into memory.
• first_char = first_line[0]: copies some content of memory location pointed by first_line into memory location pointed by first_char
• if first_char in ['a', 'e', 'i', 'o', 'u']: requires the CPU to compare several memory location and then choose a branch based on that.
• result1 = 2 ** (1/3.0) and result1 = 2 ** (1/2.0) involves processing to be done by computation circuitary such as ALU or FPU.
• result2 = 3 ** 2: same as above.

Reading files, making network calls and doing CPU intensive work is indiscriminately interwoven into each other. But the time required to execute each differs dramatically. Here's a table of approximate timing¹ for various operations and computer time translated to arbitary seconds:

Now with this perspective, let's revisit our earlier example.

• Line 1 and 3 will consume few hundred μ seconds because of the disk IO.
• Line 4 and 6 which deals with Main memory will require few hundreds of nano seconds.
• And finally lines 7, 9 and 11 require few CPU cycles and thus will be done in less than a nano second.

Since we have seen in the reference frame of processor, IO takes forever to return data; what does the processor do during that period? It simply idles ².

Note the instruction on line 11. It doesn't depend upon the data read from the file, yet its computation is blocked due to sequencial execution of intructions.

These callbacks can be provided as anonymous functions (λ) or named functions. Let's rewrite our earlier example pretending open and readline to be asynchronous operations.

 1: def calculateResult1(first_char):
 2:     if first_char in ['a', 'e', 'i', 'o', 'u']:
 3:         result1 = 2 ** (1/3.0)
 4:     else:
 5:         result1 = 2 ** (1/2.0)
 6: 
 7: f = open('/home/user/rndFile.txt',
 8:          'r',
 9:          lambda f: f.readline(lambda first_line: calculateResult1(first_line[0])))
10: 
11: result2 = 3 ** 2
12: 
13: # Note: this is not a valid Python code, 'open' is not asynchronous in Python.
14: # Do Not Try this at home.

Here's the diff between the two examples in English:

1. We have moved the code which processes the data read from the file into a named function calculateResult1.
2. Additionally there are 2 more lambdas³ (anonymous functions) which handles reading a line and invoking calculateResult1 using first character of the line.

Now instead of blocking on open call, our execution proceeds to execute line 11 after registering a callback with the open and readline operation.

To conclude our journey in understanding asynchronous programing, let's have example which can be fiddled with. Fireup your JavaScript console⁴ and paste the following code.

var request = new XMLHttpRequest();
request.open('GET', 'https://anuragpeshne.github.io/essays/index.html', true)

request.onload = function() {
    if (request.status >= 200 && request.status < 400) {
        console.log("Success! " + request.responseText.length + " characters received");
    } else {
        console.log("Server returned error " + request.status);
    }
}

request.onerror = function() {
    console.log("Connection Error");
}

console.log("before making the call");
request.send();
console.log("after making the call");

Here request.send() is indeed asynchronous. It is network version of open call that we saw in previous examples. We have registered two callbacks here, one onload and other onerror.

Note that the execution order of last three lines is indeterministic. If request is successful, order may be:

before making the call
After making the call
Success! xxx characters received

What would happen if url is changed to google.com⁵, or browser is disconnected from internet. This is something you should definitely try at home.