One of the main purposes of object initialization is to establish invariants such as a field being non-null or an immutable data structure containing specific values. These invariants are then implicitly assumed by the rest of the implementation, for instance, to ensure that a field may be safely dereferenced or that immutable data may be accessed concurrently.
Consequently, letting an object escape from its constructor is dangerous; the escaping object might not yet satisfy its invariants, which may lead to errors in code that relies on them. Nevertheless, preventing objects entirely from escaping from their constructors is too restrictive; it is often useful to call auxiliary methods on the object under initialization or to pass it to another constructor to set up mutually-recursive structures.
This talk presents a type system that tracks which objects are fully initialized and which are still under initialization. The type system can be used to prevent objects from escaping, but also to allow safe escaping by making explicit, which objects might not yet satisfy their invariants. We designed, formalized, and implemented our type system as an extension to a non-null type system, but it is not limited to this application. Our system is conceptually simple and requires little annotation overhead; it is sound and sufficiently expressive for many common programming idioms. Therefore, we believe it to be suitable for mainstream use.