[Callbacks are significantly faster](https://hackernoon.com/nodejs-48x-faster-if-you-go-back-to-callbacks) than `Promise`s in Node.js. How can we get the performance of callbacks while benefiting from the `Promise` and async/await syntax? JavaScript could introduce *CallbackAwaitExpression*, which syntactically would look very much like the existing *AwaitExpression* but it would operate on top of callbacks instead of promises. The callbacks would have the following form: ```ts type Callback<V, E = unknown> = ErrorCallback<E> | ValueCallback<V>; type ErrorCallback<E = unknown> = (error: E) => void; type ValueCallback<V> = (error: void, value: V) => void; ``` The new *CallbackAwaitExpression* would have an extra **identifier** parameter of type `Callback`, syntactically in between the `await` keyword and the expression being awaited, for example, note the `cb` identifier: ```js await cb fs.readFile('myfile.txt', 'utf-8', cb); ``` Likewise, the async function syntax would also be extended allow *AsyncCallbackFunction* type. There as well, the syntax would allow a single callback identifier: ```js async cb function(args, cb) { // ... } ``` Putting this all together, this would allow to write async/await syntax-powered code, while benefiting from the performance of callbacks. It would allow to write functions like: ```js async _ function getFileData(filename, _) { try { const data = await _ fs.readFile('myfile.txt', 'utf-8', _); return 'mydata: ' + data; } catch (error) { if (!!error && typeof error === 'object' && error.code === 'ENOENT') { throw new Error('not found'); } throw error; } } ``` The code would be equivalent to the existing JavaScript: ```js function getFileData(filename, callback) { const onCatch = (error) => { if (!!error && typeof error === 'object' && error.code === 'ENOENT') { callback(new Error('not found')); } callback(error); }; try { fs.readFile('myfile.txt', 'utf-8', (err, data) => { if (err) return onCatch(err); callback(null, 'mydata: ' + data); }); } catch (error) { onCatch(error); } } ``` Here is how the above code can look like using the existing async/await syntax. The code is almost equivalent to the *async/await callback* proposal, but less performant due to `Promise` usage. ```js async function getFileData(filename) { try { const data = await promisify(fs.readFile('myfile.txt', 'utf-8')); return 'mydata: ' + data; } catch (error) { if (!!error && typeof error === 'object' && error.code === 'ENOENT') { throw new Error('not found'); } throw error; } } ```