The paper by Maurice Herlihy, titled "Wait-Free Synchronization," explores the problem of constructing wait-free implementations of concurrent data objects. A wait-free implementation guarantees that any process can complete any operation in a finite number of steps, regardless of the execution speeds of other processes. The author introduces a technique based on reduction to a consensus protocol to prove that certain objects cannot be implemented wait-free using others. Specifically, a hierarchy of objects is derived, where no object at one level can be implemented wait-free using objects at lower levels. Atomic read/write registers, which have been the focus of recent attention, are at the bottom of this hierarchy and cannot be used to construct wait-free implementations of many simple and familiar data types. Classical synchronization primitives like *test&set* and *fetch&add* are also shown to be computationally weak. However, the paper also demonstrates the existence of universal objects from which any sequential object can be implemented wait-free. The results highlight the limitations of certain multiprocessor architectures and suggest that further progress in wait-free synchronization requires exploring more fundamental primitives. The paper is organized into sections covering the model of computation, impossibility results, universal objects, and conclusions.The paper by Maurice Herlihy, titled "Wait-Free Synchronization," explores the problem of constructing wait-free implementations of concurrent data objects. A wait-free implementation guarantees that any process can complete any operation in a finite number of steps, regardless of the execution speeds of other processes. The author introduces a technique based on reduction to a consensus protocol to prove that certain objects cannot be implemented wait-free using others. Specifically, a hierarchy of objects is derived, where no object at one level can be implemented wait-free using objects at lower levels. Atomic read/write registers, which have been the focus of recent attention, are at the bottom of this hierarchy and cannot be used to construct wait-free implementations of many simple and familiar data types. Classical synchronization primitives like *test&set* and *fetch&add* are also shown to be computationally weak. However, the paper also demonstrates the existence of universal objects from which any sequential object can be implemented wait-free. The results highlight the limitations of certain multiprocessor architectures and suggest that further progress in wait-free synchronization requires exploring more fundamental primitives. The paper is organized into sections covering the model of computation, impossibility results, universal objects, and conclusions.