11 ms·
Update on await syntax in Rust
- CJefferson 7y agoI'm nit going to stop using rust, but I find this very disappointing. One thing I strongly disagree with - - this article said other notations would require Rust users having to learn more notation. This still requires learning more notation, just it's easy to not even be aware it exists and think a struct had a member called await instead...
- Pahr3yah 7y agoAwait is a keyword, syntax highlighters will most likely paint it differently.
- kbenson 7y agoI find the syntax highlighting argument odd. It's like arguing a road surface is acceptable because the dangerous conditions it causes are mitigated by traction control.
- burntsushi 7y agoI find the don't-consider-syntax-highlighting-at-all argument odd. It's like arguing traffic lights shouldn't use colors to indicate stop-and-go because some people either cannot perceive the color difference or choose to wear glasses that negate the color difference. (Analogies here suck. Instead, consider that the vast majority of programmers read code that has been syntax highlighted. To completely discount that experience at all would be odd.)
- kbenson 7y ago> It's like arguing traffic lights shouldn't use colors to indicate stop-and-go because some people either cannot perceive the color difference or choose to wear glasses that negate the color difference. There is a reason that we have three separate lights still instead of one (that is, there's more reasons than just inertia), and that's because some people can't tell the color differences. Specifically, my father can't easily tell the color difference between green and yellow. I've had friends that also had this problem. It's not uncommon. > To completely discount that experience at all would be odd I'm not saying to discount it entirely, but consider it in context. I think it's a somewhat elitist argument, because it assumes everyone both has syntax highlighting set up and that their highlighting will work as well as yours. I accept that syntax highlighting helps, and is a positive if it can be applied well to a solution, I just think it's far from sufficient. Put another way, an optional, environment specific configuration setting is not sufficient to offset the negative aspects of an official language level feature, if we're able to weigh things prior to being implemented. If Rust were required (or even officially expected) to be written in an environment where that was always available and easily configurable, I would think different. E.g. if we're talking about Visual Basic, or Smalltalk with it's IDE (IIRC, not that I have experience with it), then I would think different, but as long as the Rust compiler is expected to take in files of text and not some rich format that includes extra metadata, I don't think language design choices should weigh non-text considerations too heavily.
- pjmlp 7y agoGiven that my first syntax highlighting experience was Turbo Pascal 7.0 for MS-DOS, it always feels odd to see it disabled. And we aren't in the late 70's anymore, where languages had design decisions (keywords always caps) due to printing limitations.
- burntsushi 7y ago> but consider it in context Which is exactly what has been done. So I don't understand what you're complaining about. The rest of your comment is a giant straw man. I've never heard of or seen implied that anyone in any decision making position in the Rust project is "assuming everyone has syntax highlighting set up." When you make ridiculous assumptions about the decision procedures of other people, then it's easy to derive ridiculous conclusions. But reality is always more nuanced than that: https://news.ycombinator.com/item?id=20031706 https://news.ycombinator.com/item?id=20031706
- kbenson 7y agoI never made an argument about the Rust project assuming that. I'm talking about people using the availability syntax highlighting to dismiss a negative aspect of a possible choice. I was making that argument in general, but spurred by a specific comment here. I used the context of the Rust community discussion as an example, but never did I assume Rust was using this as a metric (just noting that it has been put forth in arguments from the community). My argument at this point (as illustrated by the Rust discussion) is simply: - Rust/rustc takes in unicode text as source - Since it has no knowledge at the source level of syntax highlighting, using that to mitigate the downside of a language level syntax for a feature is problematic - We as the public should keep that in mind when discussing the relative merits of one possible implementation or another of a feature. That's not denigrating or assuming Rust actually did this, it's a note about the community level discussion and how some people approached it, as evidenced by a very specific comment in this thread, and how I thought it had some problems when applied to language level decisions.
- burntsushi 7y ago
- dllthomas 7y agoI think it's totally reasonable to judge a road surface based on how effective it is, in practice, with the kinds of traffic that will be travelling on it. Traction control is a part of that landscape. Designing with awareness of syntax highlighting makes sense. But we should also keep an awareness that it won't always be there.
- kbenson 7y ago> I think it's totally reasonable to judge a road surface based on how effective it is, in practice, with the kinds of traffic that will be travelling on it. Yes, and if we outlawed the use of cars without traction control on certain roads, then I would be fine with designing with the assumption traction control will be on. But as long as you allow older cars without traction control to still drive on the road, you are making the roads less safe for a certain percentage or class of drivers. I view that as different that just making the road safer for some. > But we should also keep an awareness that it won't always be there. Exactly. And this is why I think it doesn't make sense as a mitigation to a language level feature which will always be there. Specifically, I think syntax highlighting is a useful feature and a plus for a comparison, I just don't think it works as a mitigation for a negative for something that pervasive. All other things being equal, syntax highlighting abilities might push me towards one solution over another, but they won't make me ignore a problem I perceive with a solution.
- dllthomas 7y agoI'm not sure if you read me as slightly more critical than I had intended or if I'm reading you as slightly more defensive than you'd intended, but I think we more-or-less agree: readability is important both with and without syntax highlighting, and tradeoffs should be considered in that light. A nitpick: > But as long as you allow older cars without traction control to still drive on the road, you are making the roads less safe for a certain percentage or class of drivers. Probably. But if a sufficient fraction of cars have traction control, and we sufficiently improve the performance of traction controlled tires at sufficiently small damage to the performance of other tires, the reduction in the threat of being hit by cars with traction control will outweigh the increase in risk of losing control for those cars without, even before trading off risk between cars (which is certainly more complicated). I don't think there's a direct mapping back to syntax and highlighting.
- JoshTriplett 7y agoSpeaking as a member of the Rust language team: we specifically evaluated all syntax proposals on the assumption that many people may end up reading them without syntax highlighting. People read code in many places outside of a programmer's text editor or a code-highlighting web page, including logs, diffs, and emails.
- Touche 7y agoHopefully you didn't make a decision based on some exception use case.
- kibwen 7y agoThe parent commenter does not suggest that this syntax was chosen based on assuming users don't have syntax highlighting, only that they did take into consideration that not all users have syntax highlighting.
- Touche 7y agoI understand that, but how much into consideration? Let's just make up some numbers, if 1% of reading of Rust code takes place in environments without code highlight, then it should have been 1% of the consideration. Is that the case?
- jcranmer 7y agoI don't think you should weight it like that. If you have multiple proposed syntaxes, and both are equally effective with code highlighting but one is moderately ineffective without highlighting, then it makes sense that you should go for the latter. The weighting controls how much of an effectivity loss in the code highlighting case you would be willing to trade off against effectivity improvements in the other case.
- Touche 7y agoIt sounds like you're agreeing with me. If two options are indeed essentially equal on all fronts, then one minor use case can be enough to push it towards a winner.
- kbenson 7y agoMy understanding of the issue (which is shallow at best) is that it's a battle between a prefixing keyword or sigil which has the problem of causing the reader to scan back and forth in the statement when chaining multiple items, which sucks), or a postfixing keyword or sigil, with dot notation for a keyword to help parsing (and everyone seems to dislike the overloading of the dot notation for this). Ignoring sigils, I think the chosen solution is the lesser of two evils. That said, I think a postfixing sigil would have been much better. It seems an important enough thing to denote that a bit of special syntax is called for, and the more unique the better.
- 0815test 7y ago> That said, I think a postfixing sigil would he been much better. It seems an important enough thing to denote that a bit of special syntax is called for They can still introduce a sigil later, if the .await syntax turns out to be common enough in code that the long keyword hinders readability. This is how it was done with the try!(...) feature, which now uses ? as a sigil. But as the article points out, pure sigils are a scarce resource so .await might well be the best way to go anyway.
- Nican 7y agoFor example, on C#, I sometimes have to do: var value = (await (await startRequest()).GetBody()).Root; While the Rust syntax would make this a little more clear, I do not think it is a dealbreaker.
- jcelerier 7y agothis makes my eyes bleed
- zeroDivisible 7y agoWhy?
- entropicdrifter 7y ago
- burke 7y agoYeah this argument doesn't hold water for me either. Learning new notation versus learning a special-cased exception to the normal semantics of an existing piece of notation feel like really comparable levels of cognitive overhead to me. I don't think this is necessarily a bad choice overall but I find this particular line of reasoning a bit specious.
- numakerg 7y agoWhy couldn't they use a macro or a function? EDIT: nvm. it says in TFA not the linked writeup
- steveklabnik 7y agoIt cannot exist as a macro or function, because it transforms the code in ways they can’t. Macros can transform code, but the final output isn’t something representable in stable Rust, and so it would not compile post-expansion.
- staticassertion 7y agoWould the macro case be addressed by also supporting a prefix keyword? The post that states macros can't work does not cover this. From what I can tell: `foo.await!()` would just expand to `(await foo())`, and anyone could write their own `my_await!` macro that works similarly.
- eridius 7y agoWhat's the benefit of this?
- staticassertion 7y agoPostfix macros are a great feature in general, if accepted later. This would open the door for them, and you'd get things like: "{} + {}".format!("foo", "bar") and other niceties. It would have also solved the try macro's issues, like: result.try!() etc. There are plenty of use cases where postfix macros are awesome. Macros are already a known control flow mechanism, so a postfix macro should be very easy for both new and old rust users to understand. It isn't a fake field access, so it's already a step ahead of the competition. And you get prefix await, which every other language uses, and this addresses the singular argument against macros being used (which is that the macro could not be implemented by users), though I never felt that it was a strong argument anyway. I don't want to go back and forth discussing it. It isn't happening. I was just curious if the prefix await would have addressed that one argument.
- amelius 7y agoIt's not just learning the new notation. It's also that you probably can't override it with your own implementation (useful perhaps in embedded environments).
- kibwen 7y agoI don't see why you'd need to override await, because unlike in other languages Rust doesn't implicitly insert machinery for facilitating task execution. You need to provide your own task executor, which is the part that embedded environments would want to (and will be able to) have control over.
- hn_throwaway_99 7y agoI come from the Node world (I'm not really familiar with Rust at all), where the syntax is "await foo()", and to be honest I really like the .await syntax. First, as others have stated it makes the operator precedence clearer in my opinion. But more importantly, in my brain it makes it feel like await is a "member operator" of Promises (or I guess futures in the Rust case), so I can think "Function returns a promise, and then "calling" await on it yields and then returns the resolved object when done".
- BozeWolf 7y agoNice! That was quicker then I Expected. How far are they with the implementation? Not using rust, but following progress because it is on hackernews so much. Why does it take so long for swift to have this? Swift + iOS developers really really benefit from it. And there are loads of ios developers compared to rust developers.
- Arnavion 7y agoIt has been usable on nightly since `nightly-2019-05-09` (with https://github.com/rust-lang/rust/pull/60586 https://github.com/rust-lang/rust/pull/60586 )
- deleted 7y ago[deleted]
- tracker1 7y agoThere seems to have been a lot of groundwork for the Futures specification as well as implementations of underlying features for a while. Not too dissimilar for JavaScript's async/await syntax which needed support for Promises and Generators as progress points.
- Analemma_ 7y agoThe fact that discussions over syntax generate pages and pages of furious bickering, while discussions over semantics (which is what actually matters) get a shrug, is the ultimate example of bikeshedding in PL design. Honestly, syntax just doesn't matter. Yes, particular poor choices can impede usability, but that's not applicable here, and ultimately after two minutes or so of learning the new syntax there's no difference between this and "await foo".
- arkitaip 7y agoThis is every topic on Hacker News so I'm not sure why anyone would be surprised or really care.
- anchpop 7y agoSyntax may be irrelevant at the end of the day, but nice syntax can make a big difference in usability imo. I'm not following the Rust example, but discussions of it remind me about discussions about UFCS (Universal Function Call Syntax). That's where `foo(a, b)` can be rewritten as `a.foo(b)`. That may seem minor, but look at this code: half_square = divide(square(a), 2) In comparison to: half_square = a.square().divide(2) Many find the latter much more pleasant to read, and things like this can make a big difference in how fun I find it to use a language.
- Retra 7y agoWhat's a big difference for you got to do with the design of a language used by many others? What makes your experience more important than the experiences of someone with different qualifications? Why is optimizing for your tastes the correct thing to optimize for?
- anchpop 7y agoIf it's a big difference to me, it would be surprising if it was not a big difference to some portion of people (in either direction, I wouldn't be surprised if most people hate it). Since it makes a big difference to some portion of people, it is worth discussing. My intention with my comment was to make the argument that spending a long time discussing syntax can be a useful and productive thing for language designers to do.
- rileywatkins 7y agoWhat a milestone! This was the most impressive work in open source decision-making that I have ever followed (in my limited experience). People have contributed thousands of comments discussing this for over a year. It has even caused the team to rethink how discussions like this should be guided in the future beyond comments on GitHub issues. I cannot imagine how difficult it has been to manage it all, and I applaud and thank the Rust team for their hard work in fielding comments, weighing trade-offs, and ultimately making a decision in order to move the project forward.
- amboo7 7y agoI hope time is spent better in the future: https://wiki.haskell.org/Wadler's_Law https://wiki.haskell.org/Wadler's_Law, https://en.m.wikipedia.org/wiki/Law_of_triviality https://en.m.wikipedia.org/wiki/Law_of_triviality
- sgrove 7y agoThe nuances in this case went well beyond what I was expecting - it's actually more than just syntax, this heavily crosses over into semantics. It's been a very impressive process, and I was surprised at the power of the solution they landed on. - Rust has to find a syntax that can work with different underlying libraries (Rust can compile to lots of different targets, some will have capability to accommodate larger libraries than others) - The abstraction can't incur undue overhead (callback-based solutions may cause allocations that are hard to keep under control and will split the language if it spreads too much) - The syntax should be pleasant to write for at least the majority of people (modeling your entire application as a state machine around async computation is pretty unpleasant) - The compiler has to be able to give helpful error messages (this was a problem early on I think) - Language authors had to think about how the borrow checker would work across async points, and whether to invest in changing the language to make that possible. - and so on and so on I really loved this talk by Without Boats (the author of the friendly article) going over all this stuff, really gave me a good sense of what they were up against https://www.youtube.com/watch?v=skos4B5x7qE https://www.youtube.com/watch?v=skos4B5x7qE
- hu3 7y ago
- yingw787 7y agoI'm not familiar around the syntax, but I'm interested to know how much of this was a religious battle and how much of it results in meaningful complications for user code down the line. I've heard really good things about the Rust community (like nothing bad at all), until maybe two weeks ago when somebody mentioned this stuff. I'm a really big fan of not having religious battles. Is this syntax for native coroutines? Can it be combined with existing user and stdlib syntax? What pathways for syntax development does this decision cut off entirely, and pathways does it leave open? What did the Rust community / maintainers learn from this debate, and how can the Rust community avoid such battles in the future?
- steveklabnik 7y ago> I'm interested to know how much of this was a religious battle and how much of it results in meaningful complications for user code down the line. Due to the connotations of "religious battle", it's hard to get a good answer here. Nobody wants to be painted in this light. > Is this syntax for native coroutines? No. > Can it be combined with existing user and stdlib syntax? Yes. > What pathways for syntax development does this decision cut off entirely, and pathways does it leave open? Nothing outside of the async/await feature itself. > What did the Rust community / maintainers learn from this debate, and how can the Rust community avoid such battles in the future? This is too long for an HN comment :)
- ben509 7y ago> Due to the connotations of "religious battle", it's hard to get a good answer here. Nobody wants to be painted in this light. Haven't we all found ourselves lined up as one of a pair of camps over some heated dispute over a bit of minutiae? The whole time you know it's a bit silly, but not entirely and you feel compelled to continue to argue. Using a term like "religious battles" with tongue firmly in cheek is recognizing that we're prone to such things because we're human beings, by putting a lampshade on it.
- steveklabnik 7y agoThat requires strong social and interpersonal context, which is very difficult on the Internet.
- seanalltogether 7y agoQuestion for people more familiar with async/await semantics, how do you typically control what thread the async procedure runs on? Having spent a lot of time now in rxJava and really getting into the power of stream processing and composition, it feels like async/await is almost too simplistic.
- sagichmal 7y agoYou typically don't, as knowing which physical thread you're running in is (thankfully) becoming a relic of the past.
- ridiculous_fish 7y agoUI programming is one domain where it's important to know this.
- sagichmal 7y agoYes, that's fair. My domain is backend. (I use and love fish shell for many years now; thank you.)
- kllrnohj 7y agoSame with graphics/game programming, particularly as some APIs (looking at you, OpenGL) are entirely built on thread-local state.
- eximius 7y agoEven there, you only care that you aren't running on a particular thread, just NOT on one particular thread. You still pass it to an executor that has it's own thread pool and shouldn't be terribly concerned with the particular thread.
- imtringued 7y agoJava parallel streams use a global thread pool by default. The problem with this is that if you mix IO bound code and CPU bound code in the same thread pool the IO bound code will block the CPU bound code. If you don't explicitly choose the thread pool your code runs on then you will suffer from impossible to debug performance problems.
- apo 7y agoThe article doesn't actually show what the new syntax looks like. Nor does the article linked in the first paragraph. What's a simple example of the new syntax?
- thsowers 7y agoexpression.await
- nailer 7y agoCan you show us an example of, eg, an HTTP request?
- steveklabnik 7y agoHere is a small TCP client example: https://github.com/rustasync/runtime/blob/master/examples/tcp-client.rs https://github.com/rustasync/runtime/blob/master/examples/tc... Note "async fn main" on line 15, and the ".await"s on 21 and 24. Now, if you read my other comment about executors, this is using a crate called "runtime", which handles submitting it for you, see the `#[]` bit on line 14. Regardless, the syntax would look like this even without this crate; it just removes some boilerplate around the executor and submitting your future to it.
- mrkurt 7y agoIt's basically just like a method call on a future: use hyper::Client; let client = Client::new(); let resp = client.get(url).await;
- chucksmash 7y agoPostfixed and preceded by a dot is my understanding: pub async fn do_stuff() { // ... } // elsewhere, inside a fn // as svnpenn points out let result = do_stuff().await;
- svnpenn 7y agoawait goes inside the function, at least thats how its done with JavaScript - do you have evidence otherwise? https://developer.mozilla.org/Web/JavaScript/Reference/Operators/await https://developer.mozilla.org/Web/JavaScript/Reference/Opera...
- nathcd 7y agoAwesome, thanks Rust team! I'm super excited for this to be stabilized. > That won’t be the end of the async/await feature - there will be a lot of extensions left out of the minimum feature Is there a summary of these somewhere for perusal?
- uryga 7y agoi saw https://areweasyncyet.rs/ https://areweasyncyet.rs/ linked here, it mentions future extensions
- childintime 7y agoAll control flow mechanisms except await have their own statement: if, for, while, match. Howcome await is different? The dot await syntax might hide an await within an expression, as "just another method". You'll need to hunt it down. I feel await has costs and consequences that need to be explicit. The dot syntax does the opposite, and therefore I feel Rust might be making a mistake of a lifetime (pun intended) on this one.
- kibwen 7y ago> All control flow mechanisms except await have their own statement: if, for, while, match. Howcome await is different? The dot await syntax might hide an await within an expression, as "just another method". You'll need to hunt it down. Not quite; Rust is an expression-favoring language, so `if`, `match`, and even the `loop` keyword can all appear deep within expressions (the first two do so somewhat commonly; the latter is comparatively rare). In addition, the error-handling operator `?` is also used within expressions. (And while we're on the topic, let's remember that even C, a statement-heavy language, also has `?` as a control-flow operator that is not in statement position.)
- NyashMyash 7y agoThis guy is so qt and nice.
- Thaxll 7y agoI'm not familiar with Rust, someone can explains why they went with .await? Is await a field / method on a class / struct?
- eximius 7y agoNone of the above. It's compiler magic. It's a keyword that says 'await on this awaitable object' (currently only a Future can be await-ed). You can read the OP which contains links to more blog posts on the reasoning. I think this is a bad decision precisely because of the questions you're asking. At least making it a 'magic method' (i.e., Future::await(...) or future.await()) with no implementation would have been better in basically every way. A 'dot' operator already exists and this just makes it confusing.
- asark 7y agoI've been planning to try out Rust for a side project, and this decision is so principle-of-most-surprise that it's got me reconsidering, wondering what other unpleasant weirdness lurks in the language. Looking down their other options in one of the linked articles, they seem to reject a couple fine ones outright and then went with one I'd have rejected outright as being too hostile to anyone who's not quite familiar with the manual, having memorized exceptions to ordinary behavior like this. I'm struggling to understand why anyone liked this one at all, let alone enough to push it to the top of the pile.
- oconnor663 7y ago> struggling to understand why anyone liked this one at all The reason this process took so long, is that most people feel exactly like you do, except that they don't agree about which proposal they hate.
- staticassertion 7y agoYeah, this is really one of the only big warts, and hopefully not a trend. But the rest of the language is really good so don't let this scare you off. Most of rust feels very well thought out and reasonable.
- tracker1 7y agoTime to update https://areweasyncyet.rs/ https://areweasyncyet.rs/ again... Really looking forward to this once it reaches down into some of the network/web frameworks, database drivers etc.
- eximius 7y agoExcited for the feature. Disappointed we didn't get something like a magic method (e.g., lang item) (which isn't without precedence [1] [2]) so we could have had `Future::await(fut)` or `fut.await()`. [1] - https://manishearth.github.io/blog/2017/01/10/rust-tidbits-box-is-special/ https://manishearth.github.io/blog/2017/01/10/rust-tidbits-b... [2] - https://manishearth.github.io/blog/2017/01/11/rust-tidbits-what-is-a-lang-item/ https://manishearth.github.io/blog/2017/01/11/rust-tidbits-w...
- eridius 7y ago`fut.await()` looks too magical. There's no hint in that expression that it's anything other than a method call. You could argue the same about `fut.await`, except in this case `await` is a keyword and thus the expression `x.await` is known to be an await expression without knowing anything about `x`, whereas `fut.await()` requires knowing the type of `fut` to understand that the method call `.await()` resolves to the lang item. Also, since it's a lang item, you could write your own nostd library that picks a different name for the same lang item and cause even more confusion.
- eximius 7y ago> There's no hint in that expression that it's anything other than a method call. Compared with `fut.await`... > There's no hint in that expression that it's anything other than a field access. At least there is precedence for functions to have magical compiler-ness for 'doing stuff', instead of overloading field access which is one of the simplest operations you can have. > ... requires knowing the type of `fut` ... tbh, you don't need to know how await works. It goes and does stuff and returns a value. If you need to know what it does, you're looking up the types and seeing, 'oh its a future' and looking at that. Contrast with the field access one and you don't even know its something else entirely. I guess I just don't buy that it can't be a method. Like, formally, yea, it isn't a well-defined, safe Rust method. But make the impl fn await(self: Self) -> Self::Target { intrinsic::await(self) } Now its a method defined on the `Future` trait, it's discoverable, it's clearly magic, it's ergonomic... In my opinion, it beats the field access one in every conceivable metric. It's just frustrating, I guess.
- ben509 7y agoA bit off-topic: Is there any theoretical reason you need async / await syntax at all? (It's certainly desirable for performance and compatibility to avoid making all subroutines into coroutines, so I understand why most languages have done this.) And restricting it to the case where coroutines have a single return... Subroutines are naturally coroutines that don't yield. And it seems like the question of whether it's a subroutine or a coroutine shouldn't be something the programmer needs to worry about. What I've seen in coroutine libraries is the main reason we need await seems to be for cases when we don't want to await a result. If you need an unawaited invocation to pass to a routine like gather, you do this: my_results = await gather(run_job(x) for x in work) But, even if we can't infer from the type of gather that it must accept a future, a function can have a method that asks it to return a future: my_results = gather(run_job.future(x) for x in work) You'd often want to dispense with gather. If I have these statements: alpha = run_alpha() beta = run_beta() gamma = run_gamma() return alpha + beta + gamma In most cases, e.g. if these were requests going over the network, we'd prefer to schedule all three at once. If we want to sequence side-effects, then explicit await makes sense: alpha = run_alpha.await() beta = run_beta.await() gamma = run_gamma.await() return alpha + beta + gamma That makes the most concurrent option easiest, as opposed to the clunky idiom of "gathering" many results.
- steveklabnik 7y agoIn an abstract sense, no. In rust, it matters a lot. The first reason is that we don’t have a runtime. The second is stuff like http://aturon.github.io/2018/04/24/async-borrowing/ http://aturon.github.io/2018/04/24/async-borrowing/
- ben509 7y agoThanks for the link, I'm definitely interested in how it's done without a runtime. I know in theory a coroutine can compile down to a gory switch statement and some state, but doing anything useful with it gets hairy, I'm sure.
- steveklabnik 7y ago
- kgraves 7y agoFantastic! I'm extremely excited with this update on the Rust async/await syntax! I have been following the blog posts and the issue tracker for a long time and couldn't wait till this day arrived! Eagerly waiting for the 1.37 release! Great job Rust Team!
- wst_ 7y agoI am amazed how well documented and transparent was the whole process. They new the decision would be difficult to make and there will always be people who wouldn't like the final syntax so they made sure to state their reasoning and trade offs clearly. Fantastic job. Can't wait for August. Thanks!
- Dowwie 7y agoI think that the majority of people still don't understand what they're not getting in August. It's an async-await mvp.