When I first learned about the idea that GET-WORD! evaluation allowed you to get an UNSET!, I thought that was kind of cool.
But over time, it began to bother me, because when I'd see a GET-WORD! I didn't really know why it was being used. Was it to avoid invoking a function, or was it to avoid triggering a variable-is-unset error? I'd often get bitten by the case where I was trying to just disarm a function without realizing it was unset all along.
Ren-C's behavior of GET will return NULL if something is not set...allowing you to either work with that (or let it error if where you're passing it doesn't take NULL), or blankify it with try get, or trigger an error on the spot if it's not set with really get. So if you write get foo you're getting the nullable behavior previously possible with just :foo.
This makes me wonder if it would be saner if GET-WORD! errored on unset variables. That way, you could assume seeing :FOO meant you were trying to deactivate an action! so it wouldn't run (or it had some dialected purpose, or was passed to a soft quote, etc.) But it would give people the certainty that the person who wrote :FOO intended for it to be bound and set.
Because historical R3-Alpha, Rebol2, and Red GET all error on unset variables, and GET-WORD! does not, this would be the reverse bias of their behavior.
But I think the GET form reads more naturally when combined with constructs that might operate on NULL. Compare:
x: :foo else [...]
x: get 'foo else [...]
x: try :foo
x: try get 'foo
x: :foo
x: get 'foo
And as mentioned, I've found that many cases of writing things like x: :foo wind up surprised when foo is not set, because they were trying to duplicate an action.
Any objections? The change would obviously be for both GET-PATH! and GET-WORD!