In Ruby, what happens when code reassigns a constant such as MAX_RETRIES, and why is assigning one inside a method a SyntaxError?

## What makes a name a constant In Ruby any identifier that starts with an **uppercase letter** is a constant: `MAX_RETRIES`, `Config`, `HTTPClient`. Class and module names are constants too. A constant is a **name bound to an object** in a class, module or the top level (top-level constants live on `Object`). Ruby treats constants as *intended* to be set once, but it does not strictly enforce that at run time. ## Reassignment: allowed, with a warning At the top level or directly inside a `class`/`module` body, assigning to an existing constant succeeds: ```ruby MAX_RETRIES = 3 MAX_RETRIES = 5 # warning: already initialized constant MAX_RETRIES # warning: previous definition of MAX_RETRIES was here p MAX_RETRIES # => 5 ``` - The constant now refers to the new object. - Inside a class the warning names the owner, for example `already initialized constant Client::TIMEOUT`. - The warning is emitted by default, not only under `ruby -w`. Silencing warnings, for example with `-W0` or by setting `$VERBOSE` to `nil`, hides it. - Any object that captured the **old value**, such as a local assigned earlier or an object built with it, keeps the old object. ## Inside a method: a SyntaxError ```ruby def reset_limits MAX_RETRIES = 3 # SyntaxError: dynamic constant assignment end ``` The whole file fails to parse, even if the method is never called. The reasoning is that a method body can run any number of times, so an assignment there would make the constant's value depend on call history. The parser rejects it outright. - **`Module#const_set`** sets a constant at run time and is allowed inside methods: `self.class.const_set(:MAX_RETRIES, 3)`. It goes through the same code path as a normal assignment, so replacing an existing constant still prints the "already initialized constant" warning. - If a value genuinely changes at run time, it is not a constant: store it in an instance variable, a configuration object or an argument instead. ## The warning covers the binding, not the object | Operation | Warning? | Result | |---|---|---| | `MAX_RETRIES = 5` again at top level | yes, "already initialized constant" | name now points to 5 | | `MAX_RETRIES = 5` inside `def` | file does not parse | `SyntaxError` | | `Object.const_set(:MAX_RETRIES, 5)` | yes, same warning | name now points to 5 | | `TAGS << "sale"` where `TAGS = ["new"]` | none | the array itself changes | The last row surprises people: the constant still points to the same array, so Ruby has nothing to warn about. Protecting the object's contents is a separate topic (making the value immutable). ## Reading the warning The two lines Ruby prints are a ready-made trail: - the first line carries the file and line of the **new** assignment and names the constant, qualified by its class when it is not top-level; - the second line, `previous definition of TIMEOUT was here`, carries the file and line of the **earlier** assignment. Comparing the two locations usually reveals the cause at once: the same file twice (double loading), two files defining the same name (a naming collision), or a test file overriding production code. ## Where senior engineers meet this warning 1. **A file loaded twice.** `Kernel#load` re-executes a file every time, so its constants are reassigned and the warnings appear in logs. The same happens when a class body that defines a constant is reopened and run again. 2. **Tests that reassign constants.** A test that sets `Billing::RATE = 0.5` to exercise a branch changes it for every later test in the process, and produces warnings. Inject the value, or use a helper such as RSpec's `stub_const`, which restores the original. 3. **Guarded definitions.** `MAX_RETRIES = 3 unless defined?(MAX_RETRIES)` avoids the warning when a file may be evaluated twice, but hides the design problem behind it. 4. **Warnings as signals.** Treat "already initialized constant" in CI output as a bug report: something is being defined twice. ## Interview summary Say that reassignment is allowed but warned, that assignment inside a method is a parse-time `SyntaxError` (`dynamic constant assignment`), that `const_set` is the run-time escape hatch, and that the warning guards the name, not the contents of the object.