Object Anatomy

Ruby's freeze is shallow, so you recurse yourself: freeze the object, then walk Hash keys and values and Array elements. Such a helper misses state inside custom objects' instance variables, and can wrongly freeze objects the caller still shares and mutates.

The Hash placed the entry using the key's hash at insertion. Changing x changes that hash, so lookups search the wrong place and miss. Hash#rehash repairs the index; frozen keys, such as Data instances, prevent it.

Ruby has no abstract keyword, so the base class defines a stub that raises NotImplementedError naming the class and method. It only guarantees a clear error when the stub is called; nothing is checked at load time.

Check the class when duck typing cannot tell shapes apart (one Hash vs an Array of rows, both with each), when validating parsed input, or in comparisons with other. Class checks reject proxies, decorators and custom collections that would work.

private_class_method :new makes Salary.new private, so outside calls raise NoMethodError while class methods such as Salary.from_cents call new without a receiver. Salary.allocate, send, and dup or clone of an existing Salary still bypass the factories.

Since Ruby 3.0, accessing a class variable that both a class and one of its ancestors define raises RuntimeError (overtaken by the ancestor), and any @@ access at top level raises RuntimeError: class variable access from toplevel.

CRuby 3.2 introduced object shapes: objects that add the same instance variables in the same order share a shape, so inline caches hit. Assigning all of them in initialize keeps one shape per class; lazy or conditional assignments branch the tree and slow reads.

Override initialize with keyword parameters carrying defaults and checks, then call super with keywords. new and [] turn positional arguments into keywords first, and with reruns initialize for its copy, so every path hits the same checks.