Man hat eine Funktion wie
function computeSomethingA() {
const value = computeSomethingB();
processA(value);
return value;
}
Und eine Funktion wie
function computeSomethingB() {
const value = computeSomethingC();
processB(value);
return value;
}
Und eine Funktion wie
function computeSomethingC() {
const value = computeSomethingD();
processC(value);
return value;
}
…
…
…
…
…
…
Und eine Funktion wie
function computeSomethingY() {
const value = computeSomethingZ();
processY(value);
return value;
}
Und nun ändert man die Funktion computeSomethingZ() so, dass man dort eine externe library verwendet, die nicht direkt das result zurückgibt, sondern eine Promise auf das result.
Kein Problem, wir haben ja async/await, was …
… ja, hallo, Leute, ihr habt’s verbockt, und meint, eine „„Sprache““ verwenden zu müssen, die kein Konzept für mehrere Threads habt, und murxt jetzt so einen Mist zusammen, damit Leute sich weiterhin einreden sie würden mit dieser „Sprache“ ‚Software entwickeln‘ …
… da die angemessene Lösung darstellt.
Also schreibt man halt einfach
function computeSomethingY() {
const value = await computeSomethingZ();
processY(value);
return value;
}
und das Problem ist gelöst 
Schön. Idiomatisch. Kompakt.
Nun.
Jetzt muss man computeSomethingY auch async machen und beim Aufruf await davorschreiben.
Und dann computeSomethingX auch async machen, und bei ihrem Aufruf await davorschreiben.
Und dann computeSomethingW auch async machen, und bei ihrem Aufruf await davorschreiben.
…
…
…
Und dann computeSomethingC auch async machen, und bei ihrem Aufruf await davorschreiben.
Und dann computeSomethingB auch async machen, und bei ihrem Aufruf await davorschreiben.
Und dann computeSomethingA auch async machen, und bei ihrem Aufruf await davorschreiben.
Aber dann ist das Problem gelöst
Schön. Idiomatisch. Kompakt.
Echt jetzt?
Das ganze ist komplett synchron. Die ganze API suggeriert Asynchronität, die faktisch nicht vorhanden ist. Die Promises erfüllen dort keinen Zweck. Sie erzeugen eine Komplexität die im Vergleich zur vernünftigen Lösung geradezu lächerlich ist. Es ist unmöglich, das Vorhandensein irgendeiner Promise an irgendeiner Stelle des Codes im Vorfeld zu antizipieren, und wenn irgendwo eine auftaucht, bricht die gesamte Codebasis in sich zusammen wie ein Kartenhaus.
Wie wäre es mit einer „„Sprache““ Namens „JavaScript 2.0“, die sich von JavaScript nur dadurch unterscheidet, dass alle Funktionen per Default async sind, und jeder Aufruf per default mit await stattfindet?
const value = computeSomething();
// Here, 'value' is automatically a promise, and the actual
// value will be logged as soon as the promise is resolved:
console.log(value);
Was ist da draußen denn eigentlich falsch gelaufen?
