# [Python-Dev] Importance of "async" keyword

Steven D'Aprano steve at pearwood.info
Mon Jul 6 02:49:36 CEST 2015

```On Sun, Jul 05, 2015 at 11:50:00PM +0200, Sven R. Kunze wrote:

> Seems like we stick to this example once again. So, let me get this
> straight:
>
> 1) I can add, subtract, multiply and divide real numbers.
> 2) I can add, subtract, multiply and divide complex numbers.

I don't think that this is a complelling analogy for calling regular
functions and awaitable functions. Doing arithmetic is a bit more
complicated than just the four elementary operators you mention.
Contrast:

10 < 20

10+20j < 20+10j

It is not just that complex numbers can do more than real numbers. They
can also do *less*.

But aside from that, your analogy looks to me like this:

(1) I can do arithmetic on reals;
(2) I can do arithmetic on complex numbers;
(3) and I can do arithmetic on mixed real + complex expressions;

(A) I can travel in a car to the shops down the road;
(B) I can travel in a space ship to the moon;

(C) so why can't I travel in a car to the moon? Or use a space ship to
fly to the shops down the road? Because people think we cannot have
the best things of both worlds!

It seems to me that if "people think we cannot have the best things of
both worlds" (your words), it is because there are solid reasons for
that belief.

Could somebody build a car that can fly to the moon? Probably, but it
would cost *more* than the combination of separate space ship plus car,
it would require as much maintenance and support as a space ship, and
the fuel economy when driving to work would be terrible. Not to mention
all the complaints about the noise and the pollution.

I think that the distinction between regular and concurrent routines is
practical and necessary, *not* just because of people's closed minds,
but because of decades of collective experience with them.

To convince me differently, you will need more than some rather dubious
analogies or arguments from theoretical purity that sequential
syncronous code is just a special case of concurrent asyncronous code.
An actual working implementation speaks most loudly of all, but at the
very least you will need to stick to concrete arguments, not analogies.

Are you aware of any other languages which have eliminated the
distinction between regular and concurrent functions? If it has already
been done, that would make a good argument in favour of your idea.

--
Steven
```