How can we block event loop?

There are lots of ways to block the event loop. Some ways block it just for awhile (like using synchronous file I/O) and some ways block it forever.

For example, this blocks it forever:

let flag = false;
setTimeout(() => {
    // this callback never gets called
    // because event loop is blocked
    flag = true;
}, 1000);

while (!flag) {
    console.log("still waiting")
}
// never get here

The issue is that the while() loop runs until the flag changes value. As long as that while loop is running, the event loop is blocked. There's a setTimeout() that wants to fire in 1 second, but it can't actually call its callback until the interpreter gets back to the event loop. But, it won't get back to the event loop until the while() loop is done. It's a deadlock which results in an infinite loop and the event loop is permanently blocked.

The setTimeout() can't call its callback until the while loop is done and the while loop won't finish until the setTimeout() runs its callback. Deadlock, infinite loop.

This blocks it for awhile while all the file operations are going on and all the processing of the files:

setTimeout(() => {
    // this doesn't get to run until all the synchronous file I/O 
    // finishes in the code below, even though the timer is set
    // for only 10ms
    console.log("finally got to run the timer callback");
}, 10);

let files = some array of files;
for (let file of files) {
    let data = fs.readFileSync(file);
    let lines = data.split("\n");
    for (let line of lines) {
        // do something
    }
}