This is actually quite an involved topic. We need to take a step back. In many languages, the concept of localization involves a scope. Variables are declared within a scope and they cannot be referenced outside of that scope. In Mathematica, there is no true scoping mechanism. Any variable can be accessed from anywhere. But there are times where localization is really useful. So, Mathematica has a way to "fake" localization. It does this through naming conventions. If you've encountered the idea of Context before, this is what I'm referring to. A variable has a fully qualified name that includes its context, but you only need to use the short name for most purposes. In a fresh session, if you type a variable like x, the full name of that variable is actually Global`x. Most of the built-in symbols we use regularly, like Plot, are in the System context, so Plot is actually System`Plot.
Okay, so we need some sort of localization mechanism. Sometimes localization happens "silently" (like when you use Set or SetDelayed) through the specific way evaluation happens. But when you need a more involved localization mechanism, you have three options: With, Block, and Module.
With is the easiest. It's a lexical replacement mechanism. That means that before any evaluation occurs, the "local" variables you've defined are replaced throughout the body of the With. It's like those "local" variables never even existed.
Module does some magic. Unbeknownst to the user, Module actually renames all of the local variables you've defined before it does anything else. This avoids naming conflicts and makes it seem like your variables are actually scoped to the Module. Try the following very simple example:
Module[{a}, a]
The output will be something like
a$4981
(the actual value depends on the state of your session at the time the Module is evaluated). And the full name of this variable is
Global`a$4981
Since it's unlikely that you will ever intentionally define a variable like a$4981, this has the effect of scoping that variable to the Module (but it's actually not truly enforced).
Okay, so what's the deal with Block? Block basically sets up a new environment that allows you to define variables, and whatever variables you define override any pre-existing variables within the Block. It's really the closest thing to a local scope that you can get in Mathematica. The main use case for Block is for side effects. You generally want to temporarily set some important system variable to a new value, but you want to be careful that this new definition isn't permanent. So, for example, my current timezone offset is -8. If I do this:
DateObject[]
I get something like this:
DateObject[{2024, 11, 18, 20, 3, 34.943531`8.295941767663606}, "Instant", "Gregorian", -8.]
If I want to mimic being in GMT, I could do this:
Block[{$TimeZone = 0}, DateObject[]]
and get
DateObject[{2024, 11, 19, 4, 4, 51.22838`8.462085597606766}, "Instant", "Gregorian", 0.]
If you don't provide an explicit option for DateObject, it will base the result on the value of
$TimeZone
set on your machine. So, we can override that side effect within Block, but not worry about it being permanent. Notice that $TimeZone never explicitly appeared inside my Block expression, but since that variable is silently used by DateObject, we get the desired effect.
Here is the general advice...
If you just want some sort of local constant, maybe to avoid duplication or to avoid calculating something multiple times, use With. Basically, always use With unless it just won't work for your situation. The next option is Module. Use Module if your "local" variables are not constant, but in fact need to be updated as part of your algorithm. Just be aware that you won't have access to these variables outside of the Module unless you somehow capture their fully qualified names. Only use Block when you want to temporarily reset a variable's value. Typically this is for System variables, but sometimes you will want to do this with your own user-defined variables. Maybe you're testing something, for example. You could always use Block if you want, but there are weird situations where things might not work as you expected. So, I prefer With, then Module, then Block.
