Practically, dynamic typing is quite different from no typing, such as with the B programming language, although I agree that it often defeats certain benefits of type systems.

strong typing

Grrrrrrr. (this term is ambiguous but still very popular for some reason https://en.wikipedia.org/wiki/Type_safety#Strong_and_weak_typing)

There are other well defined ways to describe a type system, such as:

• Static vs dynamic
• Implicit vs manifest

e.g.

• Rust’s is mostly static and sometimes optionally implicit
• Haskell’s is static and optionally implicit
• Python’s, Lua’s, etc is dynamic and implicit
• C’s is static and manifest

I think there is something to be said for keeping a language simple, though. The basic semantics of a language should be comprehensible to everyone, let the standard library have all the wacky stuff someone wanted decades ago. (macros - the lisp kind, not the C kind - make this easier)

Async has been stable for a long time. Coroutines are just syntax sugar AFAIK.

What do you mean by “abstract away”, and what about it is exclusive to headers?

Eg most languages have something like a trait or interface wherein you can put a list of definitions (optionally with a default aka “inline” implementation) which are then actually implemented elsewhere. This is considered useful by everyone because it allows multiple implementations to be associated with 1 name. They are generally not desired in cases where only 1 implementation will ever be written.

AFAIK the only use case where headers accomplish the same is if they’re treated as documentation for an API that could be implemented by any library.

Admittedly certain programming styles benefit immensely from headers, despite the drawbacks to “design as you go” programming.