News for hackers. Stuff that matters.
Re:How JavaScript works: Event loop and the rise of Async pr... by vanderZwan on Saturday October 14, 2017 @01:54PM (#15473305)
You're making me curious enough to want to see it. Would it fit in a post here or on a short gist?
Re:How JavaScript works: Event loop and the rise of Async pr... by johnsonjo on Saturday October 14, 2017 @09:10PM (#15475281)
Here's a lock implementation I made just barely as a proof of concept:

https://bl.ocks.org/johnsonjo4531/99256568deaf8c0f1685793a4a...

Basically it is used like this:

```

  var lock = new AsyncLock();

  (async () => {
    for await(var _ of lock) {
      console.log("here 1a");
      await sleep(1000);
      console.log("here 1b")
    }
  })();

  (async () => {
    for await(var _ of lock) {
      console.log("here 2a");
      await sleep(1000);
      console.log("here 2b")
    }
  })();

  /*
  When Lock is working should print:
  here 1a
  here 1b
  here 2a
  here 2b
  Without the lock it would print:
  here 1a
  here 2a
  here 1b
  here 2b 
  */
```

If you want to check out the implementation go to the blocks link. (which is basically just a gist that you can run). Here's the actual gist link: https://gist.github.com/johnsonjo4531/99256568deaf8c0f168579....

It requires Chrome 63 (at this point Chrome Canary) because it uses async iterators. I used this because I can close the lock automatically in case an error is thrown, the loop is broken. It only iterates one value and only after the lock is unlocked.

Re:How JavaScript works: Event loop and the rise of Async pr... by johnbender on Saturday October 14, 2017 @05:15PM (#15474351)
Not sure if this helps but I hacked this together the other day to avoid adding a real queue to a very simple application. It uses event queue ordering semantics to get FIFO behavior.

The read/write combinations to the semaphore variable need not be atomic since we know that if this thread is running there are no other threads that can be reading and then modifying it.

    MyObject.queueSemaphore = N;
    MyObject.emitter = new EventEmitter();

    MyObject.queue = function( ... ){
      // if this run can take place go
      // otherwise wait for a run-complete to try again
      if(this.queueSemaphore > 0) {
        this.queueSemaphore--;
      } else {
        // must return a promise that resolves and possibly requeues
        return new promise((resolve, reject) => {
          this.emitter.once("run-complete", () => {
            resolve(true);
          });
        }).then(() => this.queue( ... ));
      }

      this.promiseBasedProcess()
        // ... work
        .finally(() => {
          this.queueSemaphore++;
          this.emitter.emit("run-complete");
        });
    }
Re:How JavaScript works: Event loop and the rise of Async pr... by HeyImAlex on Saturday October 14, 2017 @02:04PM (#15473351)
It can just be a boolean variable called locked?
Re:How JavaScript works: Event loop and the rise of Async pr... by nitely on Saturday October 14, 2017 @03:03PM (#15473651)
Almost. In threaded programming a thread will wait/block until the lock is released and then make use of the protected resource. In async world you would probably just check some flag and if it's "locked" then register a callback to some "unlocked" event to mimic this.
Re:How JavaScript works: Event loop and the rise of Async pr... by anonacct37 on Saturday October 14, 2017 @08:40PM (#15475165)
Re:How JavaScript works: Event loop and the rise of Async pr... by nitely on Saturday October 14, 2017 @08:54PM (#15475223)
Looks nice. How is this implemented?
Re:How JavaScript works: Event loop and the rise of Async pr... by rdtsc on Saturday October 14, 2017 @11:02PM (#15475663)
Not gp, but I used Twisted Matrix for a few years. It is usually implemented with a boolean flag and a list of client waiting to be called back when the lock is released.

So users of the lock would call acquire and get back a deferred (a promise in other language), but say in the most basic way, a callback is passed to it. When lock can be acquired, that callback is called (or deferred is fired).

When done with the resource, must call the release. Release then will trigger the lock to inspect the list of available waiting clients, pick one and fire their callback letting them know they can access the resource, and so on.

https://github.com/twisted/twisted/blob/trunk/src/twisted/in...

Re:How JavaScript works: Event loop and the rise of Async pr... by amelius on Saturday October 14, 2017 @03:40PM (#15473812)
"Promises" are a lot like locks.
Re:How JavaScript works: Event loop and the rise of Async pr... by ChristianBundy on Saturday October 14, 2017 @06:38PM (#15474708)
Yep.

  let lock;
  
  const log = (msg) => {
    lock = new Promise(async (resolve) => {
      await lock;
      console.log(msg);
      setTimeout(resolve, 1000);
    });
  };

  'hello world'.split('').forEach(log);
Re:How JavaScript works: Event loop and the rise of Async pr... by foota on Saturday October 14, 2017 @04:30PM (#15474102)
I don't have access to the code anymore, unfortunately. But it kept track of a list of people waiting on the lock and then notified the first caller off the list when the lock was released. It was only beautifully simple with respect to what it would have been in a non single-threaded evnironment.

I needed it in order to use a library that had some annoying global state in it.