# Await/Async, part deux

**URL:** <https://forums.swift.org/t/await-async-part-deux/37491>\
**Category:** Pitches\
**Created:** [June 12, 2020, 4:37am UTC](https://forums.swift.org/t/await-async-part-deux/37491 "2020-06-12T04:37:43Z")\
**Posts on this page:** 1\
**Showing post:** 30

<div class="post-metadata">

**Author:** ![Nevin](https://sea2.discourse-cdn.com/swift/user_avatar/forums.swift.org/nevin/32/617_2.png) [@Nevin](https://forums.swift.org/u/Nevin)\
**Post date:** [June 12, 2020, 1:39pm UTC](https://forums.swift.org/t/await-async-part-deux/37491/30 "2020-06-12T13:39:44Z")

</div>

If it is truly sequential, then I see no need of an “`await`” keyword.

Every method call is _already_ sequential. Control flow _always_ waits for each line to complete before moving on to the next.

If we are going to introduce a keyword, then it should be to specify the thing that stands out and is different. Namely, there should be a keyword for “don’t wait”. In other word, a keyword for actual asynchronous execution in the background.

I see no benefit whatsoever to explicitly marking _some_ calls as “wait for this to complete then do the rest of the stuff below it”, when in fact _all_ code works that way.

If the execution order is linear and control flow moves down one line at a time, then that is the standard, normal, existing, basic operation model. That’s how things _should_ work with no annotation, so we should not introduce an annotation that means “this works the normal way, just as it looks”.

If we want to eliminate the pyramid of doom, then just make it so we can eliminate it. As a programmer, I don’t care what happens internally, I don’t care how the compiler makes it happen, I already today don’t truly grok what the compiler does for normal code, I just know the result is indistinguishable from each statement being executed sequentially in source order.

If the compiler secretly transforms

```swift
B
C
D

```

into

```swift
B(completion: {
  C(completion: {
    D(completion: {
    
    })
  })
})

```

there’s no reason for me as a programmer to know about it or think about it or care about it. It should just work. I write `B C D`, and my program works as if those statements are performed one after another, just like I wrote them.

There’s no need or benefit to making me add extra cruft to tell the compiler to have them happen one after another, that’s already implied by the fact that they are sequential statements.

---

_[View the full topic](https://forums.swift.org/t/await-async-part-deux/37491)._