Almost all languages today are memory safe, thereby providing simple and strong guarantees to all programs. Yet the concurrency semantics of these “safe” languages causes similar problems as arise in memory-unsafe languages: small program errors can expose implementation details, violate fundamental language abstractions, and compromise program safety. Perhaps surprisingly, this is the case not only for imperative languages like Java and C++ but also for functional languages that support shared-memory concurrency. In this talk Ill overview the state of concurrency semantics as it exists today and argue that “safe” languages (and particularly declarative ones) must support the simple interleaving semantics of threads known as sequential consistency (SC). Along the way Ill debunk a few persistent myths about SC and argue that it is a practical choice for many languages today.