News for hackers. Stuff that matters.
Re:Writing a Non-Blocking JavaScript Quicksort by mpweiher on Wednesday June 10, 2015 @04:22AM (#9690655)
Is computation becoming a special case of being blocked (on I/O)?

I remember seeing this in an event-driven server framework (computation as the special case), this usage of "non-blocking" suggests it might be a trend.

Re:Writing a Non-Blocking JavaScript Quicksort by jerf on Wednesday June 10, 2015 @09:43AM (#9692084)
"Is computation becoming a special case of being blocked (on I/O)?"

No, it's been one for a long time. We call this situation "cooperative multithreading". (If you object to the "threading" term, bear in mind we called it this long before everything was multi-core.) We have learned to prefer pre-emptive multithreading on the grounds that while cooperative multithreading may occasionally have small advantages, it frequently has massive disadvantages, and the balance isn't even close.

Unfortunately, the browser has had all kinds of work done on it over the years that deeply assumed cooperative multithreading was the order of the day, and it's very difficult to change that out now. I do not mean that as a sarcastic statement or something, I mean, seriously, changing a codebase or specification base the size of the browser from cooperative to pre-emptive is an incredible and very difficult change. Computation blocks are a huge and ongoing problem if you want really low-latence javascript, and while there's not "nothing" you can do about it, the tools are pretty crude and limited.

Re:Writing a Non-Blocking JavaScript Quicksort by the8472 on Wednesday June 10, 2015 @05:41AM (#9690861)
Javascript is a special problem child there because a large part of it's raison d'être is DOM manipulation and yet that's the thing that cannot be parallelized, even with web workers because the DOM has not been designed with any kind of parallelism in mind.

Other ecosystems also have problems with computations on the UI thread but running most of the application logic on different threads comes far more natural there and standard libraries offer a much richer support for multi-threading/fine-grained task execution (be it mutable or immutable shared state).

Re:Writing a Non-Blocking JavaScript Quicksort by mattdw on Wednesday June 10, 2015 @05:10AM (#9690765)
In the browser, Javascript (outside of webworkers) is single-threaded, and while running it blocks the browser run-loop (for the given webpage.) This means the page can't accept or respond to any incoming events. It's "blocked" from interaction.
Re:Writing a Non-Blocking JavaScript Quicksort by mpweiher on Wednesday June 10, 2015 @05:34AM (#9690839)
Yes, I am aware of that.

It used to be "blocked" meant "process is waiting for an external event, usually I/O". Doing computation was typically referred to as "busy". "Non-blocking" meant "without putting the process to sleep".

There seems to be a shift in the meaning of this particular piece of terminology that I find interesting, because it seems to reflect the reality that "computers" actually do very little "computing". Instead computers mainly communicate, and even the CPUs themselves probably spend most of their time waiting on main memory (60ns) rather than doing actual arithmetic (sub ns in most cases).

Re:Writing a Non-Blocking JavaScript Quicksort by couchand on Wednesday June 10, 2015 @10:09AM (#9692266)
Just to get a little more specific with this: the shift is in the accepted "main engine of computation" (to make up a mediocre term). We used to have something of an engineer's viewpoint, that the physical location of the electrical operation of the mathematics (i.e., the CPU) was this main engine. It's been a long road, but the new viewpoint is a bit more philosophical: the main engine is the human-computer nexus.

Of course, "human" in the above isn't strictly correct, since we know that computers talk to each other all the time, too. Indeed, when that happens the main engine of computation isn't really one or the other of the computers, but the link between them (i.e., the protocol).

So now "blocking" means requiring the main engine of computation to "sleep" and wait for "external input". For a human UI this means the classic sense of waiting on the wetware end, but it can just as easily mean waiting on the hardware end.

We strive to build responsive systems, so we wish for them to be "non-blocking" in every case. This means, if the human wants to communicate to the computer, it shouldn't be prevented to because the computer is currently working on a solitary operation. Ultimately it's the same principle we've already accepted from the reverse direction.

Re:Writing a Non-Blocking JavaScript Quicksort by amalcon on Wednesday June 10, 2015 @06:59AM (#9691138)
This confused me quite a bit as well. "Wait, what? There's such a thing as a blocking quicksort? Maybe with mutexes or something, but this is JavaScript..."

Apparently "non-blocking" is used here to mean roughly the opposite of what it normally means (that your computation doesn't slow down the I/O). Oddly enough, this seems kind of reasonable for interactive programs: the I/O is the more important part, so it's the thing you want to not interfere with.

It's still a little confusing.