Despite decades of research in shared-memory concurrency and in the semantics of programming languages, there is still no adequate answer to the following fundamental question: What is the right semantics for concurrent shared-memory programs written in higher-level languages? The difficulty in answering this question is that any solution will have to balance the conflicting desiderata of programmers, compilers, and hardware. Previous attempts either allow spurious "out-of-thin-air" program behaviours or incur a non-negligible implementation cost. Nevertheless, we show that the question can be answered elegantly with the novel notion of promises: a thread may promise to execute a write in the future, thus enabling other threads to read from that write out of order. This idea alone suffices to explain most of the relaxed consistency behaviours observed as a result of compiler and hardware optimisations, while ruling out "out-of-thin-air" behaviours.