Normally I would agree with you, but lately that doesn't seem to be the case.
I've been doing a lot of interviews lately and probably the one thing people have consistently showed a keen understanding of is promises. Where people have slipped up the most? this. While I get this is tricky (it's already been brought up a few times in this thread) I've also always considered promises to have a bit of a learning curve, especially compared to the more classic callback approach. But I guess learning material nowadays, and I guess apis in general, use them so much that people need to learn them a lot sooner than before...? Not sure, but I thought that was a little interesting takeaway from these interviews.
Edit: This said with a sample set of "advanced beginners"
...unless the function was created with bind() or an arrow function. And then you have changes of behavior based on strict mode...
There's another part of this thread where someone argues that this isn't confusing, but I'm not sure there's anything else as complicated as it is in JS. So relatively speaking, it's up there.
out of curiosity, if you ask that question, what are you looking for? Considering that in modern code, this is used far less in a confusing place than it used to be -- i haven't used it outside of classes where it generally makes sense, or interacting with libraries that have a generally ridiculous dependency on it (ie, the callback that the library uses has to access 'this' to get results.. which is, frankly, about one of the dumbest things i've ever seen)
I ask questions, have people do a small coding challenge, and also have them review a PR. With the questions, I don't dig too deep into it, but ask things like where you might see problems in the use of this and things like how arrow functions are different from other functions where I expect the handling of this to be mentioned. If something comes up in that conversation that seems off, I might prod a little more which might lead down a path showing they might misunderstand it more.
The coding challenge is something done from scratch, so use of this is up to them (its small enough that I don't think I've ever seen it used) but the PR is littered with poor uses of this. Even when people catch these, it's not uncommon that its for the wrong reasons.
The PR isn't terribly unlike some of the code we have in our codebase, particularly the older, more legacy code. There are a lot of classes (constructor functions, no class) and uses of promises without await and other callbacks that can cause problems when you're not handling this correctly. It's important people can deal with this code just as well as the newer stuff.
I think I was very lucky to be learning JS *before* Promises were standard in the language, but when they were still available via libraries like Q and Bluebird. It helped me recognize the relationships between Promises and callbacks a lot sooner.
However important to note that async/await is just syntactic sugar around Promises. The syntax is nice but sometimes not as flexible. And an async function is just a function that returns a promise, even if you never await anything inside it.
Yes, exactly. I agree with both your points. I find async await makes a lot more sense in given contexts, where others it may not or you need additional functionality. I switch between the two depending on the given context.
Yeah especially waiting for promises to resolve and parallel stuff with async/await.
For example i see this in a lot of my code reviews with new js programmers:
// does some parallel async stuff
arrayOfItems.forEach(async item => {
await doSomethingAsync(item)
})
doSomethingWhenDone()
This won't wait for the promise to actually resolve outside of the forEach and call doSomethingWhenDone(). If your program exist it will not wait for your async work to be done.
Also, this is a pet peeve of mine: when I see a function that returns a promise being called w/async+await around it (as inside your map function). You've just wrapped one promise in another, and all it's done is added overhead which does take some performance hit. In your example, it could just be written as `await Promise.all(arrayOfItems.map(doSomethingAsync));` (That's about as many operations as I would put on one line though :)
I believe this would wait for each promise to resolve before moving onto the next loop.
The Promise.all() solution allows each async call to happen async concurrently; only moving on once all promises resolve (regardless of the order in which they resolve).
That's a horrible, and unfortunately very common, take. Once you're famiar with promises, you should just stick to the functional/declarative path and generally forget that async/await exists.
135
u/theMightyPanda27 May 28 '19
Promises. They are quite tricky to understand for a beginner, but very convenient as one masters.