Pseudosynchronous JavaScript

https://codewords.recurse.com/issues/three/pseudosynchronous-javascript

by bglusman • 11 years ago

62 25 11 years ago

codewords.recurse.com

skrebbel• 11 years ago

I like the idea, it's a bit like how lazy list processing works, but then applied to promises.

However, I don't completely see the appeal as soon as ES6 or ES7 transforms with a tool like Babel are ok for you. ES7 is probably going to have C#-like async/await syntax[0], which takes this problem away entirely and in a much less complicated matter. This syntax works great today with babeljs. And even if you don't dare using experimental ES7 features yet, you can accomplish just about exactly the same with ES6 generators[1].

If you really really need to avoid compiling your code, then I can see the appeal of this "pseudosynchronous" idea, but I do feel that it's much more complex and error prone than setting up a build process instead.

[0] https://github.com/lukehoban/ecmascript-asyncawait [1] http://davidwalsh.name/async-generators

xg15• 11 years ago

I think debugabillity of this would be a huge problem. It's enough of a hassle to single-step through "traditional" asynchronous code. Using the proposed pseudo-synchronous interfaces, the only thing your own code basically does is to specify what should be executed, but not actually executing anything by itself.

At the time things are actually executed, you're almost 100% in library code, making stepping through your program extremely hard.

I'm surprised the article doesn't mention spawn functions or the async/await proposal for ES7[1], which seem to solve the same problem in a way that could be both more efficient and more debug friendly.

[1] http://jakearchibald.com/2014/es7-async-functions/

inglor7• 11 years ago

The promise usage here is so terrible it's not even funny. I've made a gist of how it'd look like with correct usage. Just contrast the single level of nesting (for the branching) in the correct version vs. the 5 nesting levels version in the incorrect version used in the article https://gist.github.com/benjamingr/d08cfe94d3f0db1f954d

Not to take away from the original thought in the post - but it's hard to take a criticism on a model seriously where the OP doesn't understand the model. Here's a related StackOverflow question on the topic stackoverflow.com/questions/22539815/arent-promises-just-callbacks

inglor7• 11 years ago

The reason this works is that promises are already representative of queues of pending values. To contrast, here's the ES7 version (works with babel) I added to the gist https://gist.github.com/benjamingr/d08cfe94d3f0db1f954d#file...

It's awesome that it's a post by someone who just attended the recourse center and they're a new programmer and already struggling with these interesting issues and trying to solve them - but I beg people who attack these issues to read existing material :)

chimeracoder• 11 years ago

It's awesome that it's a post by someone who just attended the recourse center and they're a new programmer and already struggling with these interesting issues and trying to solve them

FYI, not everyone who attends the Recurse Center is a new programmer. In this particular case, Michelle (the author) has a decade and a half of experience developing in Javascript and writing Javascript frameworks (ie, writing the frameworks themselves).

sirsuki• 11 years ago

If only I could upvote this more than once. I'd upvote this to 100! That was my first take on the article. Why the hell would anyone write promises like that?!

mAritz• 11 years ago

It's rather common to see promises used as pseudo-callbacks actually. I think it has to do with the fact that just assigning something async (the promise) to a variable seems so counter-intuitive to someone who has programmed with callbacks for a while.

madeofpalk• 11 years ago

It appears you've changed the API though? Just chain the promises instead of nesting them https://gist.github.com/joshhunt/e3761594d10bb7025bcb

frank-weindel• 11 years ago

That's how I'd do it.

inglor7• 11 years ago

Chaining them is also perfectly viable (still one nesting level), as long as you're not dipicting a non-existing problem ("callback hell") it's all good. I used .call since OP used Q promises in the article - this works about as well with other libraries.

kevincennis• 11 years ago

I'm a little unclear on this stuff:

  connection.call('collection', 'users');

Is `connection` a function? As in, you're essentially using Function#call and passing the string 'collection' as `thisArg`?

Or is `call` a custom method of whatever `connection` is an instance of?

I was under the impression from the article that `DatabaseClient` was just sort of an example, not a specific implementation of anything.

It seems like you're making some unusual assumptions about its API – unless I'm totally missing something.

renekooi• 11 years ago

`.call` is a method in some Promise libraries (eg. Bluebird). Basically,

    connection.call('collection', 'users')

is a shorthand for:

    connection.then(value => value.collection('users'))

msteigerwalt2• 11 years ago

The promise usage here is so terrible it's not even funny.

Unnecessary hyperbole aside, I think you're confusing two conflicting goals. One is to provide code examples in order to explain a particular concept to an audience not already familiar with that concept, by building upon examples previously explained in the article. Another is to explain how to write production code using existing promises frameworks.

For the purposes of explanation, I used a similar code flow as the standard callback example previously described, except that I included the chaining of error handling with parallels to synchronous try/catch/finally flows.

The promises excerpt you've derided is an example of what promises bring to the table over straight callbacks for simplifying complex chains of asynchronous operations, not an example of how to use promises in production code.

Additionally, this is an article about framework design, not how to use them, making your corrections (which involve using a framework with chainable proxy queues) somewhat tangental to the discussion.

var users = connection.call('collection', 'users');

You seem to have the generic concept of a promise confused with a particular promises implementation with some extensions that you particularly like.

Not all promises libraries support `call`, and many don't support the return of the expected proxy interface from another proxy interface, which is the very technique described in the article.

The Promises/A[0] specification barely touches upon the subject and specifies that call "returns a promise to provide the return value of the requested function call," not a chainable proxy to the expected return interface. Even the Promises/A+[1] spec seems to ignore the subject of `call` entirely.

it's hard to take a criticism on a model seriously where the OP doesn't understand the model.

This isn't a criticism of the model, it's an explanation of the model and some suggested extensions.

Considering I clearly stated both in the intro and the conclusion, "This approach builds on promises and standard callbacks" and, "The great thing about this technique is that it can compose really well with existing promise frameworks," I'm really curious as to how you managed to miss that point.

To demonstrate, here's a simple diff of your "correct" example enhanced using my proposed technique:

https://gist.github.com/Yuffster/4ca84f31cfaef33c4138/revisi...

I think we can both agree that, to a developer not possessing your level of skill, the revised example is slightly easier to follow.

It's awesome that it's a post by someone who just attended the recourse [sic] center and they're a new programmer and already struggling with these interesting issues and trying to solve them

Thank you very much for the encouraging words, but in the future, could you do everyone a favor and either read an author's biography or click on the author link before making wild assumptions about his or her programming background?

The context might make it easier for you to understand the article itself, making your comments far more valuable.

---

[0] http://wiki.commonjs.org/wiki/Promises/A

[1] https://promisesaplus.com/

inglor7• 11 years ago

I used a similar code flow as the standard callback example previously described, except that I included the chaining of error handling with parallels to synchronous try/catch/finally flows.

You do the promise-as-a-pyramid example, then say you still have to nest and leave it at that, misrepresentation if not malice. Basically, you have a solution through promises you're not showing either because you were unaware or because you chose to, I _hope_ it's the former.

not an example of how to use promises in production code.

I have some 3 year old production code that begs to differ :)

Additionally, this is an article about framework design, not how to use them, making your corrections (which involve using a framework with chainable proxy queues) somewhat tangental to the discussion.

Promises are not a framework, and your proxy queues don't make sense for someone who understand promises. If you go look at Mark Miller's original work on promises you'll see that promises are proxies for asynchronous actions - that's why they were created in the first place. It's also a great read regardless.

You seem to have the generic concept of a promise confused with a particular promises implementation with some extensions that you particularly like.

I only used that because that's the library you used in the question. With bluebird it would have been significantly nicer.

The Promises/A[0] specification

Promises/A is an old specification about _interoperability_ that no one (its authors included) care about anymore.

Even the Promises/A+[1] spec

Promises/A+ is a spec about interoperability between promise libraries. It only specifies `then` and even there only what it must.

This isn't a criticism of the model, it's an explanation of the model and some suggested extensions.

Then I'm sorry but it's not a particular good one, really, I don't know who you are and I mean no offence but I think your article does a disservice to promises.

I'm really curious as to how you managed to miss that point.

Your technique added an _extra layer_ on top of an _existing layer_ that already _solves the problem you're solving_. Promises were designed to be callback queues from the 80s by Barbara Liskov and Mark Miller. Reinventing the core concepts is insanely cool but it does a big disservice to the existing tooling.

I think we can both agree that, to a developer not possessing your level of skill, the revised example is slightly easier to follow.

I think it conflates promises with values, we've offered this technique in Bluebird for years now as an example in https://github.com/petkaantonov/bluebird/blob/master/API.md (see under "Using defaultPromisifier parameter to add enhancements on top of normal node promisification:) without anything more than `.all`ing the arguments.

Thank you very much for the encouraging words, but in the future, could you do everyone a favor and either read an author's biography or click on the author link before making wild assumptions about his or her programming background?

I apologize for this, totally my bad. Is there anything you made that I'd recognise from JS land?

The context might make it easier for you to understand the article itself, making your comments far more valuable.

I don't want to turn this into a pissing contest but I'm pretty sure I understand promises, proxies and all that. I apologize for the tone in the original comment (I'll edit it if you'd like) it was uncalled for but I really think there is a lot to improve in the article.

impostervt• 11 years ago

I worked in a similar vein with Horseman:

http://horsemanjs.org/

The library runs PhantomJS. While there are many libraries that do this, I wanted a synchronous, chainable API. So I could do

var links = horseman.count('a'); if (count > 3) { horseman.open('http://www.google.com') } else { horseman.open('http://www.yahoo.com') }

Under the hood, using the library literally blocks. Which is a very, very un-javascript/Node thing to do, and introduces other weirdness, I know.

thesorrow• 11 years ago

Generators and channels using js-csp is much more readable in my opinion.

staltz2• 11 years ago

With RxJS, you can compose with existing Promise-based libraries, solve asynchronous programming (and error handling) in an elegant fashion with code that looks like simple linear chains (or DAGs) of Observables, and you don't need to give up non-blocking JS. https://www.youtube.com/watch?v=XRYN2xt11Ek

findjashua2• 11 years ago

eventstreams are handy for handling a stream of events (user actions in UI, streaming API client), but when a request gets a single event as a response (ajax/http), async/await looks like a much simpler option (functions return the output, instead of taking a handler to process it). Thoughts?

PS: enjoyed your talk 'user is a function', looking forward to how cycle evolves.

staltz2• 11 years ago

What is an event? Put differently: what cannot be an event in your application?

Pseudosynchronous JavaScript

Related Stories